resource:
  attributes:
    service.instance.id: "822605ce-9284-4d0d-971a-9a1bc24c4c83"
    service.name: "scout.application.name from config.properties"
    telemetry.sdk.language: "java"
    telemetry.sdk.name: "opentelemetry"
    telemetry.sdk.version: "1.31.0"
  scopeMetrics:
    io.opentelemetry.runtime-telemetry-java8:
    scout.SqlConnectionPool:
      metrics:
        db.client.connections.wait_time:
          description: "The time it took to obtain an open connection from the pool.",
          unit: "ms",
          histogram:
            dataPoints: "count|sum|min|max|bucket",
            attributes:
              pool.name: "com.example.server.services.SqlService"
        db.client.connections.usage:
          description: "The number of connections that are currently in state described by the state attribute.",
          unit: "{connection}",
          sum:
            dataPoints:
            attributes:
              pool.name: "com.example.server.services.SqlService"
              state: "idle|used"
        db.client.connections.max:
          description: "The maximum number of open connections allowed."
          unit: "{connection}"
          sum:
            dataPoints:
            attributes:
              pool.name: "com.example.server.services.SqlService"
  org.eclipse.scout.rt.shared.session.SessionMetricsHelper:
    metrics:
      scout.sessions.created:
        description: "The number of sessions that has been created since server start.",
        unit: "{session}",
        sum:
          dataPoints:
          attributes:
            type: "ui|client|server|http"
        isMonotonic: true
      scout.sessions.active:
        description: "The number of active sessions."
        unit: "{session}"
        sum:
          dataPoints:
          attributes:
            type: "ui|client|server|http"

@ApplicationScoped
public class SessionManagementService implements IGlobalSessionListener {
  private static final Logger LOG = LoggerFactory.getLogger(SessionManagementService.class);
  private final MBeanServer mBeanServer;
  private final Map<String, WeakReference<ClientSession>> clientSessions;
  private final Map<String, WeakReference<ISession>> serverSessions;

  public SessionManagementService() {
    mBeanServer = ManagementFactory.getPlatformMBeanServer();
    clientSessions = new WeakHashMap<>();
    serverSessions = new WeakHashMap<>();
  }

  public SessionTablePageData getSessionTableData() {
    if (!ACCESS.check(new ReadSessionPermission())) {
      throw new VetoException(TEXTS.get("AuthorizationFailed"));
    }
    ObjectName sessions = MBeanUtility.toJmxName("org.eclipse.scout.rt.ui.html", "Sessions");
    SessionTablePageData sessionTablePageData = new SessionTablePageData();
    try {
      Object sessionDetails = mBeanServer.getAttribute(sessions, "SessionDetails");
      if (sessionDetails instanceof CompositeData[] compositeDataArray) {
        var sessionRows = Arrays.stream(compositeDataArray).map(this::createSessionTableRow).toArray(SessionTableRowData[]::new);
        sessionTablePageData.setRows(sessionRows);
      }
    } catch (MBeanException | AttributeNotFoundException | InstanceNotFoundException | ReflectionException e) {
      LOG.error("Error while querying MBean", e);
      throw new VetoException(TEXTS.get("mgmt.sessions.error.mbean", e.getClass().getSimpleName(), e.getMessage()));
    }
    return sessionTablePageData;
  }

  private SessionTableRowData createSessionTableRow(CompositeData compositeData) {
    var clientSessionId = compositeData.get("clientSessionId") instanceof String clientSessionIdString ? clientSessionIdString : "";
    var clientState = compositeData.get("clientState") instanceof String clientStateString ? clientStateString : "";
    var userId = compositeData.get("userId") instanceof String userIdString ? userIdString : "";
    var ageInSeconds = compositeData.get("ageInSeconds") instanceof Long ageInSecondsLong ? ageInSecondsLong : 0L;
    var httpSessionId = compositeData.get("httpSessionId") instanceof String httpSessionIdString ? httpSessionIdString : "";
    var lastAccessed = compositeData.get("lastAccessed") instanceof Date lastAccessedLong ? lastAccessedLong : null;
    var uiSessionId = compositeData.get("uiSessionId") instanceof String uiSessionIdString ? uiSessionIdString : "";
    var uiState = compositeData.get("uiState") instanceof String uiStateString ? uiStateString : "";

    SessionTableRowData row = new SessionTableRowData();
    row.setClientSessionId(clientSessionId);
    row.setClientState(clientState);
    row.setUserId(userId);
    row.setAgeInSeconds(ageInSeconds);
    row.setHttpSessionId(httpSessionId);
    row.setLastAccessed(lastAccessed);
    row.setUiSessionId(uiSessionId);
    row.setUiState(uiState);
    var userAgent = findUserAgent(clientSessionId);
    row.setUserAgent(userAgent);
    return row;
  }

  private String findUserAgent(String clientSessionId) {
    if (clientSessions.containsKey(clientSessionId)) {
      var clientSession = clientSessions.get(clientSessionId).get();
      if (clientSession != null) {
        return clientSession.getUserAgent().toString();
      }
    }
    return "Unknown";
  }

  public void terminateSession(String clientSessionId) {
    if (!ACCESS.check(new DeleteSessionPermission())) {
      throw new VetoException(TEXTS.get("AuthorizationFailed"));
    }
    if (clientSessionId == null || clientSessionId.isBlank()) {
      return;
    }
    var clientSessionWeakReference = clientSessions.get(clientSessionId);
    if (clientSessionWeakReference == null) {
      return;
    }
    IClientSession clientSession = clientSessionWeakReference.get();
    if (clientSession == null) {
      return;
    }
    BEANS.get(ClientSessionStopHelper.class).scheduleStop(clientSession, true, "Kicked by admin.");
  }

  protected void registerClientSession(ClientSession session) {
    clientSessions.put(session.getId(), new WeakReference<>(session));
  }

  protected void unregisterClientSession(ClientSession session) {
    clientSessions.remove(session.getId());
  }

  protected void registerServerSession(ISession session) {
    serverSessions.put(session.getId(), new WeakReference<>(session));
  }

  protected void unregisterServerSession(ISession session) {
    serverSessions.remove(session.getId());
  }

  @Override
  public void sessionChanged(SessionEvent event) {
    if (event.getSource() instanceof ClientSession clientSession) {
      if (event.getType() == SessionEvent.TYPE_STARTED) {
        registerClientSession(clientSession);
      }
      if (event.getType() == SessionEvent.TYPE_STOPPED) {
        unregisterClientSession(clientSession);
      }
    } else if (!(event instanceof IClientSession) && event.getSource() != null) {
      var serverSession = event.getSource();
      if (event.getType() == SessionEvent.TYPE_STARTED) {
        registerServerSession(serverSession);
      }
      if (event.getType() == SessionEvent.TYPE_STOPPED) {
        unregisterServerSession(serverSession);
      }
    }
  }
}