import { flushPromises, mount } from '@vue/test-utils';
import { VMenu } from 'vuetify/components';
import SettingsMenu from '@/components/modal/menus/SettingsMenu.vue';
import { reactive } from 'vue';
import { inflateScanState } from '@/functions/modelHelper';
import OtaClient from '@crowdin/ota-client';
import { createTestingPinia } from '@pinia/testing';
import { createPinia, setActivePinia } from 'pinia';

vi.mock('@/stores/language.store', async (importOriginal) => {
  return {
    ...(await importOriginal<typeof import('@/stores/language.store')>()),
    useLanguageStore: vi.fn().mockReturnValue({
      getLanguages: vi
        .fn()
        .mockResolvedValue([
          { language: 'english', editorCode: 'en', crowdinLanguageCode: 'en', code: 'en', countryCode: 'en' }
        ]),
      language: 'jpn'
    })
  };
});

vi.mock('pinia', async (importOriginal) => {
  return {
    ...(await importOriginal<typeof import('pinia')>()),
    storeToRefs: vi.fn().mockReturnValue({
      language: { value: 'jpn' },
      loading: { value: false }
    })
  };
});

describe('SettingsMenu', () => {
  setActivePinia(createPinia());
  vi.spyOn(OtaClient.prototype, 'listLanguages').mockResolvedValue([]);

  it('should open menu when ModelValue is true', async () => {
    const wrapper = mount(SettingsMenu, {
      plugins: [createTestingPinia({ createSpy: vi.fn })]
    });
    const menu = wrapper.findComponent(VMenu);
    await menu.setValue(true);
    expect(menu.isVisible()).toBe(true);
  });
  it('should update brightness modelValue', async () => {
    vi.spyOn(OtaClient.prototype, 'listLanguages').mockResolvedValue([]);
    const scanState = reactive(inflateScanState());
    const wrapper = mount(SettingsMenu, {
      plugins: [createTestingPinia({ createSpy: vi.fn })],
      global: {
        mocks: {
          scanState
        }
      }
    });
    const menu = wrapper.findComponent(VMenu);
    await menu.setValue(true);
    await flushPromises();
    const brightnessField = wrapper.findComponentByTestId('brightness');
    await flushPromises();
    await brightnessField.setValue(75);

    scanState.Display.Brightness = 75;
    expect(scanState.Display.Brightness).toBe(75);
    const contrastField = wrapper.findComponentByTestId('contrast');
    await flushPromises();
    await contrastField.setValue(75);
    scanState.Display.Contrast = 75;
    expect(scanState.Display.Contrast).toBe(75);
    const opacityField = wrapper.findComponentByTestId('opacity');
    await flushPromises();
    await opacityField.setValue(75);
    scanState.Display.Opacity = 75;
    expect(scanState.Display.Opacity).toBe(75);
  });
  it('should update interactionSettings modelValue', async () => {
    vi.spyOn(OtaClient.prototype, 'listLanguages').mockResolvedValue([]);
    const scanState = reactive(inflateScanState());
    const wrapper = mount(SettingsMenu, {
      plugins: [createTestingPinia({ createSpy: vi.fn })],
      global: {
        mocks: {
          scanState
        }
      }
    });
    const menu = wrapper.findComponent(VMenu);
    await menu.setValue(true);
    await flushPromises();
    const panSensitivity = wrapper.findComponentByTestId('pan');
    await flushPromises();
    await panSensitivity.setValue(75);
    scanState.InteractionSettings.PanSensivitity = 75;
    expect(scanState.InteractionSettings.PanSensivitity).toBe(75);

    const zoomSensitivity = wrapper.findComponentByTestId('zoom');
    await flushPromises();
    await zoomSensitivity.setValue(75);
    scanState.InteractionSettings.ZoomSensitivity = 75;
    expect(scanState.InteractionSettings.ZoomSensitivity).toBe(75);

    const rotateSensitivity = wrapper.findComponentByTestId('rotate');
    await flushPromises();
    await rotateSensitivity.setValue(75);
    scanState.InteractionSettings.RotateSensitivity = 75;
    expect(scanState.InteractionSettings.RotateSensitivity).toBe(75);

    const cameraRotateSensitivity = wrapper.findComponentByTestId('cameraRotate');
    await flushPromises();
    await cameraRotateSensitivity.setValue(75);
    scanState.InteractionSettings.CameraRotateSensitivity = 75;
    expect(scanState.InteractionSettings.CameraRotateSensitivity).toBe(75);
  });
  it('should change modelValue for switch', async () => {
    vi.spyOn(OtaClient.prototype, 'listLanguages').mockResolvedValue([]);
    const scanState = reactive(inflateScanState());
    const wrapper = mount(SettingsMenu, {
      plugins: [createTestingPinia({ createSpy: vi.fn })],
      global: {
        mocks: {
          scanState
        }
      }
    });
    const menu = wrapper.findComponent(VMenu);
    await menu.setValue(true);
    await flushPromises();
    const vSwitch = wrapper.findComponentByTestId('switch');
    expect(wrapper.vm.isVisible).toBe(true);
    wrapper.vm.isVisible = false;
    vSwitch.setValue(false);
    expect(wrapper.vm.isVisible).toBe(false);
  });
  it('should change modelValue for stlResolution', async () => {
    vi.spyOn(OtaClient.prototype, 'listLanguages').mockResolvedValue([]);
    const scanState = reactive(inflateScanState());
    const wrapper = mount(SettingsMenu, {
      plugins: [createTestingPinia({ createSpy: vi.fn })],
      global: {
        mocks: {
          scanState
        }
      }
    });
    const menu = wrapper.findComponent(VMenu);
    await menu.setValue(true);
    await flushPromises();
    const resolution = wrapper.findComponentByTestId('resolution');
    await flushPromises();
    await resolution.setValue(15);
    wrapper.vm.stlResolution = 15;
    expect(wrapper.vm.stlResolution).toBe(15);
  });
  // it('should set language correctly', async () => {
  //   vi.spyOn(OtaClient.prototype, 'listLanguages').mockResolvedValue([]);
  //   const scanState = reactive(inflateScanState());
  //   const wrapper = mount(SettingsMenu, {
  //     plugins: [createTestingPinia({ createSpy: vi.fn })],
  //     global: {
  //       mocks: {
  //         scanState
  //       }
  //     }
  //   });
  //   const menu = wrapper.findComponent(VMenu);
  //   await menu.setValue(true);
  //   await flushPromises();
  //   const selectedLanguage = wrapper.findComponentByTestId('language');
  //   await selectedLanguage.setValue('english');
  //   await flushPromises();
  //   expect(selectedLanguage.vm.modelValue).toBe({});
  // });
});