import {expect, test, describe, vi, beforeEach} from "vitest"
import AdapterOfUsers from '@adapters/adapterOfUsers/Users'
import ServiceOfUsers from '@services/serviceOfUsers/Users.js'
import { createStore } from 'vuex'
import {store as users} from "@/store/modules/users"
import axios from "axios";

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 users store with vuex", () => {
  const store = createStore({
    plugins: [],
    modules: {
      users
    },
  })

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

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

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

  test('Upload Users', async () => {

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

    expect(users).toEqual([]) // empty users array of store

    await serviceOfUsers.getUsers('dev')

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

    expect(uploadUsers).not.toBe([]) // full services array of store
    expect(uploadUsers.length).toBeGreaterThan(0) // full services array of store

  })

  test('Upload users with selected service to store', async () => {

    await serviceOfUsers.getUsersByService(1, 'dev')

    const expectedUsers = defaultUsers.filter(user => user.serviceId.includes(1))

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

    expect(expectedUsers).toEqual(usersWithService) // users array selected service

  })
  
  test('Upload users withhout selected service to store', async () => {

    await serviceOfUsers.getUsers('dev')
    await serviceOfUsers.getUsersWithoutService(1)

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

    usersWithoutService.map(user => {
      expect(user.serviceId).not.toBe(1)
    })
 
  })

  test('Created and added new user layout to selected user in store', async () => {

    const newUser = await serviceOfUsers.createNewUser()

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

    expect(newUserStore.id).toBe(-1) // new user layout check id
    expect(newUserStore).toEqual(newUser) // new user layout equal
 
  })

  test('Get selected user from store', async () => {

    await serviceOfUsers.createNewUser()
    const selectedUser = await serviceOfUsers.getSelectedUser()

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

    expect(selectedUserStore).toEqual(selectedUser)
 
  })

  test('Set selected user in store', async () => {

    await serviceOfUsers.getUsers('dev')
    await serviceOfUsers.createNewUser()

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

    expect(selectedNewUserStore.id).toBe(-1) // new user layout check id

    const updatedUser = await serviceOfUsers.setSelectedUser(3)
    const updatedUserStore = store.getters['users/selectedUser']

    expect(updatedUserStore.id).toBe(3) // updated user check id
    expect(updatedUserStore).toEqual(updatedUser)
 
  })

  test('Set status user in store', async () => {

    const defaultUserStatus = store.getters['users/userStatus']

    expect(defaultUserStatus).toBe('inactive')

    const updatedUserStatus = await serviceOfUsers.setStatusUser('active')
    const updatedUserStatusStore = store.getters['users/userStatus']

    expect(updatedUserStatus).toBe('active')
    expect(updatedUserStatusStore).toEqual(updatedUserStatus)
 
  })

  test('Added user to users with selected service of store', async () => {
    
    await serviceOfUsers.getUsers('dev')
    await serviceOfUsers.addUserToService(5, 2)

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

    // console.log('usersWithServices', usersWithServices)

    const userAddedService = usersWithServices.find(user => user.id === 5)

    expect(userAddedService).toBeDefined()
    expect(userAddedService.serviceId.includes(2)).toBe(true)

  })

  test('Editing fields values in selected user', async () => {
    
    const forEditUser = 
    {
      "id": 5,
      "serviceId": [4, 5],
      "firstName": "Leanne 5",
      "lastName": "Graham",
      "email": "test@mail.ru",
      "role": "admin",
    }

    await serviceOfUsers.getUsers('dev')

    const users = store.getters['users/users']
    const userBeforeEdit = users.find(user => user.id === 5)

    expect(userBeforeEdit).toEqual(forEditUser)

    await serviceOfUsers.setSelectedUser(5)

    await serviceOfUsers.editUserByService({key: "firstName", value: "Leanne 5 edited"})
    await serviceOfUsers.editUserByService({key: "lastName", value: "Graham edited"})

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

    expect(editedUser.firstName).toEqual("Leanne 5 edited")
    expect(editedUser.lastName).toEqual("Graham edited")

    await serviceOfUsers.editUserByService({key: "firstName", value: "Leanne 5"}) // return to default value
    await serviceOfUsers.editUserByService({key: "lastName", value: "Graham"}) // return to default value

  })

  test('Deleted user from users with selected service of store', async () => {
    
    await serviceOfUsers.getUsers('dev')
    await serviceOfUsers.deleteUserFromService(5, 4)

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

    const userWithService = usersWithServices.find(user => user.id === 5)
    const userWithoutService = usersWithoutServices.find(user => user.id === 5)

    expect(userWithService).toBeUndefined() // user with service deleted
    expect(userWithoutService).toBeDefined() // user without service added
    expect(userWithoutService.serviceId.includes(4)).toBe(false) // selected service was deleted from user serviceId 

  })

  test('Saving new user to array users of selected service', async () => {
    
    const newUser = 
    {
      "id": -1,
      "serviceId": [],
      "firstName": "Leanne 5 New",
      "lastName": "Graham New",
      "email": "test@mail.ru",
      "role": "admin",
    }

    await serviceOfUsers.getUsers('dev')
    store.dispatch('users/updateSelectedUser', newUser)

    const users = store.getters['users/users']
    const countUsers = users.length

    await serviceOfUsers.saveUpdatedDataUser(3)

    const usersWithService = store.getters['users/usersWithService']
    const newUserAfterAdding = usersWithService.find(user => user.id === countUsers + 1) // Пока не получаем нового юзера с бэка, поэтому задаём id по количеству всех юзеров

    expect(newUserAfterAdding).toBeDefined()

    expect(newUserAfterAdding.id).toEqual(countUsers + 1)
    expect(newUserAfterAdding.firstName).toEqual("Leanne 5 New")
    expect(newUserAfterAdding.lastName).toEqual("Graham New")

  })

  test('Saving edited user to array users of selected service', async () => {
    
    const editedUser = 
    {
      "id": 3,
      "serviceId": [2, 3],
      "firstName": "Leanne 3 Edited",
      "lastName": "Graham Edited",
      "email": "test@mail.ru",
      "role": "admin",
    }

    await serviceOfUsers.getUsers('dev')
    store.dispatch('users/updateSelectedUser', editedUser)

    await serviceOfUsers.saveUpdatedDataUser(2)

    const usersWithService = store.getters['users/usersWithService']
    const userAfterUpdating = usersWithService.find(user => user.id === 3) 

    // console.log('userAfterUpdating', userAfterUpdating)

    expect(userAfterUpdating).toBeDefined()

    expect(userAfterUpdating.id).toEqual(3)
    expect(userAfterUpdating.firstName).toEqual("Leanne 3 Edited")
    expect(userAfterUpdating.lastName).toEqual("Graham Edited")

  })
  
  test('Reset store', async () => {
    
    const selectedUser = 
    {
      "id": 5,
      "serviceId": [4, 5],
      "firstName": "Leanne 5",
      "lastName": "Graham",
      "email": "test@mail.ru",
      "role": "admin",
    }
    
    await serviceOfUsers.getUsers('dev')
    await serviceOfUsers.setSelectedUser(5)
    await serviceOfUsers.setStatusUser('active')
    
    const selectedUserStore = store.getters['users/selectedUser']
    const users = store.getters['users/users']
    const userStatus = store.getters['users/userStatus']

    expect(selectedUser).toEqual(selectedUserStore) // User is selected
    expect(users).not.toStrictEqual([]) // Not empty users
    expect(userStatus).toEqual('active') // New user status

    await serviceOfUsers.resetStore()

    const resetSelectedUser = store.getters['users/selectedUser']
    const resetUsers = store.getters['users/users']
    const resetUserStatus = store.getters['users/userStatus']

    // console.log('Reset store 11 test', resetSelectedService)

    expect(resetSelectedUser).toBe(null) // After reset store
    expect(resetUsers).toStrictEqual([]) // After reset store
    expect(resetUserStatus).toEqual('inactive') // After reset store

  })

})