import { expect, test, describe, vi, beforeEach } from 'vitest'
import {createStore, mapGetters} from "vuex"
import { mount} from '@vue/test-utils'
import UsersTable from '@organisms/UsersManager/UsersTable.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'

vi.mock('axios')

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

describe("tests UsersManagerUsersTable 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(UsersTable, {
      global: {
        plugins: [store],
        props: {
          serviceOfUsers
        }
      }
    })

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

  test('For Editing select current user in UserEditor', async () => {

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

    await serviceOfUsers.getUsers()

    const wrapper = mount(UsersTable, {
      global: {
        plugins: [store]
      },
      components: {VTabulator},
      props: {
        serviceOfUsers
      },
      computed: {
        ...mapGetters('users', ['userStatus']),
      },
    })

    const selectedUser = store.getters['users/selectedUser']

    expect(selectedUser).toBeNull()
    expect(wrapper.vm.userStatus).toBe('inactive')

    wrapper.vm.editUser(forEditUser)

    const selectedUserAfterEdit = store.getters['users/selectedUser']
    const userStatus = store.getters['users/userStatus']

    expect(selectedUserAfterEdit).not.toBeNull()
    expect(selectedUserAfterEdit.id).toEqual(forEditUser.id)
    expect(userStatus).toBe('edit')
  })

  test('Delete user from 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 forDeleteUser = {
      "id": 2,
      "serviceId": [1],
      "firstName": "Leanne 2",
      "lastName": "Graham",
      "email": "test@mail.ru",
      "role": "admin",
    }

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

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

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

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

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

    expect(forDeleteUserFromService).not.toBeNull()
    expect(userStatus).toBe('inactive')

    wrapper.vm.deleteUser(forDeleteUser)

    setTimeout(() => {

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

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

      expect(userStatusAfterDelete).toBe('select')
      expect(userFromServiceAfterDelete).toBeUndefined()
      expect(userWithoutServiceAfterDelete).toBeDefined()
      expect(userWithoutServiceAfterDelete.id).toEqual(forDeleteUser.id)

    }, 100)

  })

})