import { expect, test, describe, vi, beforeEach } from 'vitest'
import {createStore, mapGetters} from "vuex"
import { mount} from '@vue/test-utils'
import UsersSelection from '@organisms/UsersManager/UsersForSelection.vue'
import VTabulator from '@molecules/Tabulator/VTabulator.vue'
import axios from "axios"
import {store as services} from "@/store/modules/services"
import {store as users} from "@/store/modules/users"
import AdapterOfServices    from '@adapters/adapterOfServices/Services'
import ServiceOfServices    from '@services/serviceOfServices/Services.js'
import AdapterOfUsers    from '@adapters/adapterOfUsers/Users'
import ServiceOfUsers from '@services/serviceOfUsers/Users.js'
import CaseOfUsersInService from '@useCases/CaseOfUsersInService.js'
import {defaultUsers} from "@mocks/users"

vi.mock('axios')

describe("tests UsersForSelection component", () => {

  const store = createStore({
    plugins: [],
    modules: {
      services,
      users
    },
  })

  beforeEach(async () => {
    store.dispatch('users/resetStore')
  })

  vi.mock('tabulator-tables', () => {
    const mockTabulator = vi.fn().mockImplementation(() => ({
      // Mock implementation details
    }))
    return { TabulatorFull: mockTabulator }; // Adjust based on what you're trying to mock
  })

  axios.get.mockResolvedValue({
    data: defaultUsers,
  })

  const adapterOfServices = new AdapterOfServices(import.meta.env.VITE_API_ADDR)
  const serviceOfServices = new ServiceOfServices(adapterOfServices, store)

  const adapterOfUsers    = new AdapterOfUsers(import.meta.env.VITE_API_ADDR)
  const serviceOfUsers =    new ServiceOfUsers(adapterOfUsers, store)
  
  const caseOfUsersInService = new CaseOfUsersInService(serviceOfUsers, serviceOfServices)

  test('mount test of UsersManagerUsersTable', async () => {

    const wrapper = mount(UsersSelection, {
      global: {
        mocks: {
          $store: store
        },
        props: {
          caseOfUsersInService
        }
      }
    })

    expect(wrapper.exists()).toBe(true)
  })

  test('Added user to selected Service', async () => {

    const selectedService = [
      {
        "id": 1,
        "created_at": "2024-03-06T17:31:31.948355541+03:00",
        "updated_at": "2024-03-06T17:31:31.948355541+03:00",
        "deleted_at": null,
        "name": "jsonplaceholder.typicode.com",
        "port": 9965,
        "proxy_ip": "172.25.78.153",
        "device_ip": "https://jsonplaceholder.typicode.com/",
        "internet_uri": "localhost",
        "description": "localhost",
        "is_online": true
      },
    ]

    const addedUser = {
      "id": 3,
      "serviceId": [2, 3],
      "firstName": "Leanne 3",
      "lastName": "Graham",
      "email": "test@mail.ru",
      "role": "admin",
    }

    await serviceOfServices.fetchServices()
    await serviceOfServices.selectService(selectedService[0])

    await serviceOfUsers.getUsersByService(1, 'dev')
    await serviceOfUsers.setSelectedUser(addedUser.id)

    const wrapper = mount(UsersSelection, {
      global: {
        mocks: {
          $store: store
        }
      },
      components: {VTabulator},
      props: {
        serviceOfUsers,
        caseOfUsersInService,
        users: defaultUsers,
      },
      computed: {
        ...mapGetters('users', ['selectedUser', 'usersWithoutService']),
      },
    })

    const usersWithServices = store.getters['users/usersWithService']

    const forDeleteUserFromService = usersWithServices.find(user => user.id === addedUser.id)

    expect(forDeleteUserFromService).toBeUndefined()

    wrapper.vm.addUser(addedUser)

    setTimeout(() => {

      const usersWithServicesAfterDelete = store.getters['users/usersWithService']
      const usersWithoutService = store.getters['users/usersWithoutService']

      const userFromServiceAfterDelete = usersWithServicesAfterDelete.find(user => user.id === addedUser.id)
      const userWithoutServiceAfterDelete = usersWithoutService.find(user => user.id === addedUser.id)

      expect(userFromServiceAfterDelete).toBeDefined()
      expect(userWithoutServiceAfterDelete).toBeUndefined()
      expect(userWithoutServiceAfterDelete.id).toEqual(addedUser.id)

    }, 100)

  })

})