// gui_automation_client.cc
// Implementation of gRPC client for YAZE GUI automation

#include "cli/service/gui_automation_client.h"

#include "absl/strings/str_format.h"
#include "absl/time/time.h"

#include <utility>

namespace yaze {
namespace cli {

namespace {

#ifdef YAZE_WITH_GRPC
std::optional<absl::Time> OptionalTimeFromMillis(int64_t millis) {
  if (millis <= 0) {
    return std::nullopt;
  }
  return absl::FromUnixMillis(millis);
}

yaze::test::WidgetType ConvertWidgetTypeFilterToProto(WidgetTypeFilter filter) {
  using ProtoType = yaze::test::WidgetType;
  switch (filter) {
    case WidgetTypeFilter::kAll:
      return ProtoType::WIDGET_TYPE_ALL;
    case WidgetTypeFilter::kButton:
      return ProtoType::WIDGET_TYPE_BUTTON;
    case WidgetTypeFilter::kInput:
      return ProtoType::WIDGET_TYPE_INPUT;
    case WidgetTypeFilter::kMenu:
      return ProtoType::WIDGET_TYPE_MENU;
    case WidgetTypeFilter::kTab:
      return ProtoType::WIDGET_TYPE_TAB;
    case WidgetTypeFilter::kCheckbox:
      return ProtoType::WIDGET_TYPE_CHECKBOX;
    case WidgetTypeFilter::kSlider:
      return ProtoType::WIDGET_TYPE_SLIDER;
    case WidgetTypeFilter::kCanvas:
      return ProtoType::WIDGET_TYPE_CANVAS;
    case WidgetTypeFilter::kSelectable:
      return ProtoType::WIDGET_TYPE_SELECTABLE;
    case WidgetTypeFilter::kOther:
      return ProtoType::WIDGET_TYPE_OTHER;
    case WidgetTypeFilter::kUnspecified:
    default:
      return ProtoType::WIDGET_TYPE_UNSPECIFIED;
  }
}

TestRunStatus ConvertStatusProto(
    yaze::test::GetTestStatusResponse::Status status) {
  using ProtoStatus = yaze::test::GetTestStatusResponse::Status;
  switch (status) {
    case ProtoStatus::GetTestStatusResponse_Status_STATUS_QUEUED:
      return TestRunStatus::kQueued;
    case ProtoStatus::GetTestStatusResponse_Status_STATUS_RUNNING:
      return TestRunStatus::kRunning;
    case ProtoStatus::GetTestStatusResponse_Status_STATUS_PASSED:
      return TestRunStatus::kPassed;
    case ProtoStatus::GetTestStatusResponse_Status_STATUS_FAILED:
      return TestRunStatus::kFailed;
    case ProtoStatus::GetTestStatusResponse_Status_STATUS_TIMEOUT:
      return TestRunStatus::kTimeout;
    case ProtoStatus::GetTestStatusResponse_Status_STATUS_UNSPECIFIED:
    default:
      return TestRunStatus::kUnknown;
  }
}
#endif  // YAZE_WITH_GRPC

}  // namespace

GuiAutomationClient::GuiAutomationClient(const std::string& server_address)
    : server_address_(server_address) {}

absl::Status GuiAutomationClient::Connect() {
#ifdef YAZE_WITH_GRPC
  auto channel = grpc::CreateChannel(server_address_,
                                     grpc::InsecureChannelCredentials());
  if (!channel) {
    return absl::InternalError("Failed to create gRPC channel");
  }
  
  stub_ = yaze::test::ImGuiTestHarness::NewStub(channel);
  if (!stub_) {
    return absl::InternalError("Failed to create gRPC stub");
  }
  
  // Test connection with a ping
  auto result = Ping("connection_test");
  if (!result.ok()) {
    return absl::UnavailableError(
        absl::StrFormat("Failed to connect to test harness at %s: %s",
                        server_address_, result.status().message()));
  }
  
  connected_ = true;
  return absl::OkStatus();
#else
  return absl::UnimplementedError(
      "GUI automation requires YAZE_WITH_GRPC=ON at build time");
#endif
}

absl::StatusOr<AutomationResult> GuiAutomationClient::Ping(
    const std::string& message) {
#ifdef YAZE_WITH_GRPC
  if (!stub_) {
    return absl::FailedPreconditionError("Not connected. Call Connect() first.");
  }
  
  yaze::test::PingRequest request;
  request.set_message(message);
  
  yaze::test::PingResponse response;
  grpc::ClientContext context;
  
  grpc::Status status = stub_->Ping(&context, request, &response);
  
  if (!status.ok()) {
    return absl::InternalError(
        absl::StrFormat("Ping RPC failed: %s", status.error_message()));
  }
  
  AutomationResult result;
  result.success = true;
  result.message = absl::StrFormat("Server version: %s (timestamp: %lld)",
                                   response.yaze_version(),
                                   response.timestamp_ms());
  result.execution_time = std::chrono::milliseconds(0);
  result.test_id.clear();
  return result;
#else
  return absl::UnimplementedError("gRPC not available");
#endif
}

absl::StatusOr<AutomationResult> GuiAutomationClient::Click(
    const std::string& target, ClickType type) {
#ifdef YAZE_WITH_GRPC
  if (!stub_) {
    return absl::FailedPreconditionError("Not connected. Call Connect() first.");
  }
  
  yaze::test::ClickRequest request;
  request.set_target(target);
  
  switch (type) {
    case ClickType::kLeft:
      request.set_type(
          yaze::test::ClickRequest::CLICK_TYPE_LEFT);
      break;
    case ClickType::kRight:
      request.set_type(
          yaze::test::ClickRequest::CLICK_TYPE_RIGHT);
      break;
    case ClickType::kMiddle:
      request.set_type(
          yaze::test::ClickRequest::CLICK_TYPE_MIDDLE);
      break;
    case ClickType::kDouble:
      request.set_type(
          yaze::test::ClickRequest::CLICK_TYPE_DOUBLE);
      break;
  }
  
  yaze::test::ClickResponse response;
  grpc::ClientContext context;
  
  grpc::Status status = stub_->Click(&context, request, &response);
  
  if (!status.ok()) {
    return absl::InternalError(
        absl::StrFormat("Click RPC failed: %s", status.error_message()));
  }
  
  AutomationResult result;
  result.success = response.success();
  result.message = response.message();
  result.execution_time = std::chrono::milliseconds(
      response.execution_time_ms());
  result.test_id = response.test_id();
  return result;
#else
  return absl::UnimplementedError("gRPC not available");
#endif
}

absl::StatusOr<AutomationResult> GuiAutomationClient::Type(
    const std::string& target, const std::string& text, bool clear_first) {
#ifdef YAZE_WITH_GRPC
  if (!stub_) {
    return absl::FailedPreconditionError("Not connected. Call Connect() first.");
  }
  
  yaze::test::TypeRequest request;
  request.set_target(target);
  request.set_text(text);
  request.set_clear_first(clear_first);
  
  yaze::test::TypeResponse response;
  grpc::ClientContext context;
  
  grpc::Status status = stub_->Type(&context, request, &response);
  
  if (!status.ok()) {
    return absl::InternalError(
        absl::StrFormat("Type RPC failed: %s", status.error_message()));
  }
  
  AutomationResult result;
  result.success = response.success();
  result.message = response.message();
  result.execution_time = std::chrono::milliseconds(
      response.execution_time_ms());
  result.test_id = response.test_id();
  return result;
#else
  return absl::UnimplementedError("gRPC not available");
#endif
}

absl::StatusOr<AutomationResult> GuiAutomationClient::Wait(
    const std::string& condition, int timeout_ms, int poll_interval_ms) {
#ifdef YAZE_WITH_GRPC
  if (!stub_) {
    return absl::FailedPreconditionError("Not connected. Call Connect() first.");
  }
  
  yaze::test::WaitRequest request;
  request.set_condition(condition);
  request.set_timeout_ms(timeout_ms);
  request.set_poll_interval_ms(poll_interval_ms);
  
  yaze::test::WaitResponse response;
  grpc::ClientContext context;
  
  grpc::Status status = stub_->Wait(&context, request, &response);
  
  if (!status.ok()) {
    return absl::InternalError(
        absl::StrFormat("Wait RPC failed: %s", status.error_message()));
  }
  
  AutomationResult result;
  result.success = response.success();
  result.message = response.message();
  result.execution_time = std::chrono::milliseconds(
      response.elapsed_ms());
  result.test_id = response.test_id();
  return result;
#else
  return absl::UnimplementedError("gRPC not available");
#endif
}

absl::StatusOr<AutomationResult> GuiAutomationClient::Assert(
    const std::string& condition) {
#ifdef YAZE_WITH_GRPC
  if (!stub_) {
    return absl::FailedPreconditionError("Not connected. Call Connect() first.");
  }
  
  yaze::test::AssertRequest request;
  request.set_condition(condition);
  
  yaze::test::AssertResponse response;
  grpc::ClientContext context;
  
  grpc::Status status = stub_->Assert(&context, request, &response);
  
  if (!status.ok()) {
    return absl::InternalError(
        absl::StrFormat("Assert RPC failed: %s", status.error_message()));
  }
  
  AutomationResult result;
  result.success = response.success();
  result.message = response.message();
  result.actual_value = response.actual_value();
  result.expected_value = response.expected_value();
  result.execution_time = std::chrono::milliseconds(0);
  result.test_id = response.test_id();
  return result;
#else
  return absl::UnimplementedError("gRPC not available");
#endif
}

absl::StatusOr<AutomationResult> GuiAutomationClient::Screenshot(
    const std::string& region, const std::string& format) {
#ifdef YAZE_WITH_GRPC
  if (!stub_) {
    return absl::FailedPreconditionError("Not connected. Call Connect() first.");
  }
  
  yaze::test::ScreenshotRequest request;
  request.set_window_title("");  // Empty = main window
  request.set_output_path("/tmp/yaze_screenshot.png");  // Default path
  request.set_format(
      yaze::test::ScreenshotRequest::IMAGE_FORMAT_PNG);  // Always PNG for now
  
  yaze::test::ScreenshotResponse response;
  grpc::ClientContext context;
  
  grpc::Status status = stub_->Screenshot(&context, request, &response);
  
  if (!status.ok()) {
    return absl::InternalError(
        absl::StrFormat("Screenshot RPC failed: %s", status.error_message()));
  }
  
  AutomationResult result;
  result.success = response.success();
  result.message = response.message();
  result.execution_time = std::chrono::milliseconds(0);
  result.test_id.clear();
  return result;
#else
  return absl::UnimplementedError("gRPC not available");
#endif
}

absl::StatusOr<TestStatusDetails> GuiAutomationClient::GetTestStatus(
    const std::string& test_id) {
#ifdef YAZE_WITH_GRPC
  if (!stub_) {
    return absl::FailedPreconditionError("Not connected. Call Connect() first.");
  }

  yaze::test::GetTestStatusRequest request;
  request.set_test_id(test_id);

  yaze::test::GetTestStatusResponse response;
  grpc::ClientContext context;

  grpc::Status status = stub_->GetTestStatus(&context, request, &response);

  if (!status.ok()) {
    return absl::InternalError(
        absl::StrFormat("GetTestStatus RPC failed: %s", status.error_message()));
  }

  TestStatusDetails details;
  details.test_id = test_id;
  details.status = ConvertStatusProto(response.status());
  details.queued_at = OptionalTimeFromMillis(response.queued_at_ms());
  details.started_at = OptionalTimeFromMillis(response.started_at_ms());
  details.completed_at = OptionalTimeFromMillis(response.completed_at_ms());
  details.execution_time_ms = response.execution_time_ms();
  details.error_message = response.error_message();
  details.assertion_failures.assign(response.assertion_failures().begin(),
                                    response.assertion_failures().end());
  return details;
#else
  return absl::UnimplementedError("gRPC not available");
#endif
}

absl::StatusOr<ListTestsResult> GuiAutomationClient::ListTests(
    const std::string& category_filter, int page_size,
    const std::string& page_token) {
#ifdef YAZE_WITH_GRPC
  if (!stub_) {
    return absl::FailedPreconditionError("Not connected. Call Connect() first.");
  }

  yaze::test::ListTestsRequest request;
  if (!category_filter.empty()) {
    request.set_category_filter(category_filter);
  }
  if (page_size > 0) {
    request.set_page_size(page_size);
  }
  if (!page_token.empty()) {
    request.set_page_token(page_token);
  }

  yaze::test::ListTestsResponse response;
  grpc::ClientContext context;

  grpc::Status status = stub_->ListTests(&context, request, &response);

  if (!status.ok()) {
    return absl::InternalError(
        absl::StrFormat("ListTests RPC failed: %s", status.error_message()));
  }

  ListTestsResult result;
  result.total_count = response.total_count();
  result.next_page_token = response.next_page_token();
  result.tests.reserve(response.tests_size());

  for (const auto& test_info : response.tests()) {
    HarnessTestSummary summary;
    summary.test_id = test_info.test_id();
    summary.name = test_info.name();
    summary.category = test_info.category();
    summary.last_run_at =
        OptionalTimeFromMillis(test_info.last_run_timestamp_ms());
    summary.total_runs = test_info.total_runs();
    summary.pass_count = test_info.pass_count();
    summary.fail_count = test_info.fail_count();
    summary.average_duration_ms = test_info.average_duration_ms();
    result.tests.push_back(std::move(summary));
  }

  return result;
#else
  return absl::UnimplementedError("gRPC not available");
#endif
}

absl::StatusOr<TestResultDetails> GuiAutomationClient::GetTestResults(
    const std::string& test_id, bool include_logs) {
#ifdef YAZE_WITH_GRPC
  if (!stub_) {
    return absl::FailedPreconditionError("Not connected. Call Connect() first.");
  }

  yaze::test::GetTestResultsRequest request;
  request.set_test_id(test_id);
  request.set_include_logs(include_logs);

  yaze::test::GetTestResultsResponse response;
  grpc::ClientContext context;

  grpc::Status status = stub_->GetTestResults(&context, request, &response);

  if (!status.ok()) {
    return absl::InternalError(
        absl::StrFormat("GetTestResults RPC failed: %s",
                        status.error_message()));
  }

  TestResultDetails result;
  result.test_id = test_id;
  result.success = response.success();
  result.test_name = response.test_name();
  result.category = response.category();
  result.executed_at = OptionalTimeFromMillis(response.executed_at_ms());
  result.duration_ms = response.duration_ms();

  result.assertions.reserve(response.assertions_size());
  for (const auto& assertion : response.assertions()) {
    AssertionOutcome outcome;
    outcome.description = assertion.description();
    outcome.passed = assertion.passed();
    outcome.expected_value = assertion.expected_value();
    outcome.actual_value = assertion.actual_value();
    outcome.error_message = assertion.error_message();
    result.assertions.push_back(std::move(outcome));
  }

  if (include_logs) {
    result.logs.assign(response.logs().begin(), response.logs().end());
  }

  for (const auto& metric : response.metrics()) {
    result.metrics.emplace(metric.first, metric.second);
  }

  return result;
#else
  return absl::UnimplementedError("gRPC not available");
#endif
}

absl::StatusOr<DiscoverWidgetsResult> GuiAutomationClient::DiscoverWidgets(
    const DiscoverWidgetsQuery& query) {
#ifdef YAZE_WITH_GRPC
  if (!stub_) {
    return absl::FailedPreconditionError("Not connected. Call Connect() first.");
  }

  yaze::test::DiscoverWidgetsRequest request;
  if (!query.window_filter.empty()) {
    request.set_window_filter(query.window_filter);
  }
  request.set_type_filter(ConvertWidgetTypeFilterToProto(query.type_filter));
  if (!query.path_prefix.empty()) {
    request.set_path_prefix(query.path_prefix);
  }
  request.set_include_invisible(query.include_invisible);
  request.set_include_disabled(query.include_disabled);

  yaze::test::DiscoverWidgetsResponse response;
  grpc::ClientContext context;
  grpc::Status status = stub_->DiscoverWidgets(&context, request, &response);

  if (!status.ok()) {
    return absl::InternalError(
        absl::StrFormat("DiscoverWidgets RPC failed: %s",
                        status.error_message()));
  }

  DiscoverWidgetsResult result;
  result.total_widgets = response.total_widgets();
  if (response.generated_at_ms() > 0) {
    result.generated_at = OptionalTimeFromMillis(response.generated_at_ms());
  }

  result.windows.reserve(response.windows_size());
  for (const auto& window_proto : response.windows()) {
    DiscoveredWindowInfo window_info;
    window_info.name = window_proto.name();
    window_info.visible = window_proto.visible();
    window_info.widgets.reserve(window_proto.widgets_size());

    for (const auto& widget_proto : window_proto.widgets()) {
      WidgetDescriptor widget;
      widget.path = widget_proto.path();
      widget.label = widget_proto.label();
      widget.type = widget_proto.type();
      widget.description = widget_proto.description();
      widget.suggested_action = widget_proto.suggested_action();
      widget.visible = widget_proto.visible();
      widget.enabled = widget_proto.enabled();
      widget.has_bounds = widget_proto.has_bounds();
      if (widget.has_bounds) {
        widget.bounds.min_x = widget_proto.bounds().min_x();
        widget.bounds.min_y = widget_proto.bounds().min_y();
        widget.bounds.max_x = widget_proto.bounds().max_x();
        widget.bounds.max_y = widget_proto.bounds().max_y();
      } else {
        widget.bounds = WidgetBoundingBox();
      }
      widget.widget_id = widget_proto.widget_id();
      widget.last_seen_frame = widget_proto.last_seen_frame();
      widget.last_seen_at = OptionalTimeFromMillis(widget_proto.last_seen_at_ms());
      widget.stale = widget_proto.stale();
      window_info.widgets.push_back(std::move(widget));
    }

    result.windows.push_back(std::move(window_info));
  }

  return result;
#else
  (void)query;
  return absl::UnimplementedError("gRPC not available");
#endif
}

}  // namespace cli
}  // namespace yaze