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

#ifndef CHROME_BROWSER_GLIC_TEST_SUPPORT_INTERACTIVE_TEST_UTIL_H_
#define CHROME_BROWSER_GLIC_TEST_SUPPORT_INTERACTIVE_TEST_UTIL_H_

#include "base/memory/raw_ptr.h"
#include "base/scoped_observation_traits.h"
#include "chrome/browser/glic/host/glic.mojom.h"
#include "chrome/browser/glic/public/service/glic_instance_coordinator.h"
#include "chrome/browser/glic/widget/glic_view.h"
#include "ui/base/interaction/element_identifier.h"
#include "ui/base/interaction/interactive_test.h"
#include "ui/base/interaction/polling_state_observer.h"

namespace base {
// Set up a custom `ScopedObservationTrait` for `Host::Observer`.
template <>
struct ScopedObservationTraits<glic::GlicInstanceCoordinator,
                               glic::Host::Observer> {
  static void AddObserver(glic::Host* host, glic::Host::Observer* observer) {
    host->AddObserver(observer);
  }
  static void RemoveObserver(glic::Host* host, glic::Host::Observer* observer) {
    host->RemoveObserver(observer);
  }
};
}  // namespace base

namespace glic::test {

// Possible states for the glic panel in tests.
enum class GlicPanelState {
  kClosed,
  kOpen,
};

namespace internal {


// Observes `controller` for changes to state().
// When `tab` is not null, it will return a GlicInstanceCoordinator::State
// inferred by the IsShowing() method of the instance for the given tab.
// Otherwise, it will return the state() from the controller.
class GlicInstanceCoordinatorStateObserver
    : public ui::test::PollingStateObserver<GlicPanelState> {
 public:
  explicit GlicInstanceCoordinatorStateObserver(
      const GlicInstanceCoordinator& controller,
      tabs::TabInterface* tab = nullptr);
  ~GlicInstanceCoordinatorStateObserver() override;
};

DECLARE_STATE_IDENTIFIER_VALUE(GlicInstanceCoordinatorStateObserver,
                               kGlicInstanceCoordinatorState);

// Observers the glic app internal state.
class GlicAppStateObserver
    : public ui::test::
          ObservationStateObserver<mojom::WebUiState, Host, Host::Observer> {
 public:
  explicit GlicAppStateObserver(Host* host);
  ~GlicAppStateObserver() override;
  // Host::Observer
  void WebUiStateChanged(mojom::WebUiState state) override;
};

DECLARE_STATE_IDENTIFIER_VALUE(GlicAppStateObserver, kGlicAppState);

// True when the timer is not running. Use `Start()` to start the timer.
class WaitingStateObserver : public ui::test::StateObserver<bool> {
 public:
  WaitingStateObserver();
  ~WaitingStateObserver() override;

  void Start(base::TimeDelta timeout) {
    OnStateObserverStateChanged(false);
    timer_.Start(FROM_HERE, timeout,
                 base::BindOnce(&WaitingStateObserver::OnTimeout,
                                base::Unretained(this)));
  }

 private:
  void OnTimeout() { OnStateObserverStateChanged(true); }

  base::OneShotTimer timer_;
};

DEFINE_LOCAL_STATE_IDENTIFIER_VALUE(WaitingStateObserver, kDelayState);

class WebUiStateObserver : public ui::test::StateObserver<mojom::WebUiState>,
                           public Host::Observer {
 public:
  explicit WebUiStateObserver(Host* host);

  ~WebUiStateObserver() override;

  mojom::WebUiState GetStateObserverInitialState() const override;

  void WebUiStateChanged(mojom::WebUiState state) override;

 private:
  base::ScopedObservation<Host, Host::Observer> observation_{this};
  raw_ptr<Host> host_;
};

DEFINE_LOCAL_STATE_IDENTIFIER_VALUE(WebUiStateObserver, kWebUiState);

}  // namespace internal

}  // namespace glic::test

#endif  // CHROME_BROWSER_GLIC_TEST_SUPPORT_INTERACTIVE_TEST_UTIL_H_