...

import { first } from 'rxjs';

import {
  arrayToDataFrame,
  DataQueryResponse,
  DataSourceInstanceSettings,
  getDefaultTimeRange,
  LoadingState,
  standardTransformersRegistry,
  FieldType,
  DataFrame,
  AdHocVariableFilter,
} from '@grafana/data';
import { getPanelPlugin } from '@grafana/data/test';
import { setPluginImportUtils, config } from '@grafana/runtime';
import {
  SafeSerializableSceneObject,
  SceneDataNode,
  SceneDataTransformer,
  SceneFlexItem,
  SceneFlexLayout,
  SceneObject,
  VizPanel,
} from '@grafana/scenes';
import { getVizPanelKeyForPanelId } from 'app/features/dashboard-scene/utils/utils';
import { getStandardTransformers } from 'app/features/transformers/standardTransformers';

import { MIXED_REQUEST_PREFIX } from '../mixed/MixedDataSource';

import { DashboardDatasource } from './datasource';
import { DashboardQuery } from './types';

jest.mock('rxjs', () => {
  const original = jest.requireActual('rxjs');
  return {
    ...original,
    first: jest.fn(original.first),
  };
});

standardTransformersRegistry.setInit(getStandardTransformers);
setPluginImportUtils({
  importPanelPlugin: (id: string) => Promise.resolve(getPanelPlugin({})),
  getPanelPluginFromCache: (id: string) => undefined,
});

describe('DashboardDatasource', () => {
  beforeEach(() => {
    jest.clearAllMocks();
  });

it("should look up the other panel and subscribe to it's data", async () => {
    const { observable } = setup({ refId: 'A', panelId: 1 });

let rsp: DataQueryResponse | undefined;

observable.subscribe({ next: (data) => (rsp = data) });

expect(rsp?.data[0].fields[0].values).toEqual([1, 2, 3]);
  });

it('should always set response key', async () => {
    const { observable } = setup({ refId: 'A', panelId: 1 });

let rsp: DataQueryResponse | undefined;

observable.subscribe({ next: (data) => (rsp = data) });

expect(rsp?.key).toEqual('source-ds-provider');
  });

it('Can subscribe to panel data + transforms', async () => {
    jest.useFakeTimers();

const { observable } = setup({ refId: 'A', panelId: 1, withTransforms: true });

let rsp: DataQueryResponse | undefined;

observable.subscribe({ next: (data) => (rsp = data) });

jest.runAllTimers();

expect(rsp?.data[0].fields[1].values).toEqual([3]);
  });

it('Should activate source provder on observable subscribe and deactivate when completed (if only activator)', async () => {
    const { observable, sourceData } = setup({ refId: 'A', panelId: 1, withTransforms: true });

const test = observable.subscribe({ next: () => {} });

expect(sourceData.isActive).toBe(true);

test.unsubscribe();

expect(sourceData.isActive).toBe(false);
  });

it('Should emit only the first value and complete if used within MixedDS', async () => {
    const { observable } = setup({ refId: 'A', panelId: 1 }, `${MIXED_REQUEST_PREFIX}1`);

observable.subscribe({ next: () => {} });

expect(first).toHaveBeenCalled();
  });

it('Should not get the first emission if requestId does not contain the MixedDS prefix', async () => {
    const { observable } = setup({ refId: 'A', panelId: 1 });

observable.subscribe({ next: () => {} });

expect(first).not.toHaveBeenCalled();
  });

it('Should not mutate field state in dataframe', () => {
    jest.useFakeTimers();
    const { observable } = setup({ refId: 'A', panelId: 1, withTransforms: true });

let rsp: DataQueryResponse | undefined;

const test = observable.subscribe({ next: (data) => (rsp = data) });

jest.runAllTimers();

// modifying series in dashboard DS should not affect the original dataframe
    rsp!.data[0].fields[0].state = {
      calcs: { sum: 3 },
    };

test.unsubscribe();

observable.subscribe({ next: (data) => (rsp = data) });

jest.runAllTimers();

// on further emissions the result should be the unmodified original dataframe
    expect(rsp!.data[0].fields[0].state).toEqual({});
  });

describe('AdHoc Filtering', () => {
    // Shared test utilities
    interface TestField {
      name: string;
      type: FieldType;
      values: unknown[];
    }

function createTestFrame(fields: TestField[]) {
      return {
        name: 'TestData',
        fields: fields.map((field) => ({
          name: field.name,
          type: field.type,
          values: field.values,
          config: {},
          state: {},
        })),
        length: fields[0]?.values.length || 0,
        refId: 'A',
      };
    }

function createQueryRequest(filters: AdHocVariableFilter[], scene: SceneObject, adHocFiltersEnabled?: boolean) {
      return {
        timezone: 'utc',
        targets: [{ refId: 'A', panelId: 1, adHocFiltersEnabled }],
        requestId: '',
        interval: '',
        intervalMs: 0,
        range: getDefaultTimeRange(),
        scopedVars: {
          __sceneObject: new SafeSerializableSceneObject(scene),
        },
        app: '',
        startTime: 0,
        filters: filters,
      };
    }

// Test AdHoc filtering via the Public API first, to ensure Integration
    describe('Integration (Public API)', () => {
      const originalToggleValue = config.featureToggles.dashboardDsAdHocFiltering;

beforeEach(() => {
        config.featureToggles.dashboardDsAdHocFiltering = true;
      });

afterEach(() => {
        config.featureToggles.dashboardDsAdHocFiltering = originalToggleValue;
      });

it('should apply basic filtering end-to-end through public query method', async () => {
        const testFrame = createTestFrame([
          { name: 'name', type: FieldType.string, values: ['John', 'Jane', 'Bob'] },
          { name: 'age', type: FieldType.number, values: [25, 30, 35] },
        ]);

const scene = new SceneFlexLayout({
          children: [
            new SceneFlexItem({
              body: new VizPanel({
                key: getVizPanelKeyForPanelId(1),
                $data: new SceneDataNode({
                  data: {
                    series: [testFrame],
                    state: LoadingState.Done,
                    timeRange: getDefaultTimeRange(),
                  },
                }),
              }),
            }),
          ],
        });

const ds = new DashboardDatasource({} as DataSourceInstanceSettings);
        const filters: AdHocVariableFilter[] = [{ key: 'name', operator: '=', value: 'John' }];

const observable = ds.query(createQueryRequest(filters, scene, true));