import { defineStore } from 'pinia';
import api from '../services/api'; // Importa a instância do axios
import router from '../routes/router';
import { useAuthStore } from './auth'; // Importa o AuthStore

export const useUserStore = defineStore('users', {
  state: () => ({
    usersHierarchy: null,
    user: null,
    error: null,
    loading: false,
    pagination: {},
  }),

  getters: {
    allUsers() {
      const flattenUsers = (users) => {
        return users.reduce((acc, user) => {
          if (!user.deleted) { // Ignora usuários deletados
            acc.push(user);
            if (user.subordinates?.length > 0) {
              acc.push(...flattenUsers(user.subordinates));
            }
          }
          return acc;
        }, []);
      };
      return this.usersHierarchy ? flattenUsers(this.usersHierarchy) : [];
    },
  },

  actions: {
    async fetchUsersHierarchy() {
      try {
        this.loading = true;
        const authStore = useAuthStore();
        const token = authStore.token; // Obtém o token de autenticação
        const response = await api.get('/users/hierarchy_by_user_id?responsible_id=1', {
          headers: {
            'Authorization': `Bearer ${token}`
          }
        });
        this.usersHierarchy = response.data.filter(user => !user.deleted); // Filtra usuários deletados
        return response.data.subordinates;
      } catch (error) {
        console.error('Erro ao buscar hierarquia de usuários', error);
        throw error; // Lança o erro para tratar em outro lugar
      } finally {
        this.loading = false;
      }
    },

    async fetchUsersHierarchy() {
      try {
        this.loading = true;
        const authStore = useAuthStore();
        const token = authStore.token; // Obtém o token de autenticação
        const response = await api.get('/users/', {
          headers: {
            'Authorization': `Bearer ${token}`
          }
        });
        this.usersHierarchy = response.data.filter(user => !user.deleted); // Filtra usuários deletados
        return response.data;
      } catch (error) {
        console.error('Erro ao buscar hierarquia de usuários', error);
        throw error; // Lança o erro para tratar em outro lugar
      } finally {
        this.loading = false;
      }
    },

    async catchUsers() {
      try {
        this.loading = true;
        const authStore = useAuthStore();
        const token = authStore.token;
        const response = await api.get('/users/', {
          headers: {
            'Authorization': `Bearer ${token}`
          }
        });
        
        // Filtra para manter apenas usuários não deletados
        const filteredUsers = response.data.filter(user => !user.deleted);
        this.userData = filteredUsers;
        
        // Retorna apenas os usuários não deletados
        return filteredUsers;
      } catch (error) {
        console.error('Erro ao buscar lista de usuários', error);
        throw error;
      } finally {
        this.loading = false;
      }
    },

    async createUser(userData) {
      try {
        this.loading = true;
        const authStore = useAuthStore();
        const token = authStore.token;
    
        // Função para formatar a data no formato YYYY-MM-DD
        const formatDateForMySQL = (dateString) => {
          if (!dateString) return null;
          const date = new Date(dateString);
          return date.toISOString().split('T')[0]; // Retorna apenas a parte da data
        };
    
        const formattedData = {
          admission_date: formatDateForMySQL(userData.admission_date),
          email: userData.email,
          parent_id: userData.parent_id,
          password: 'senha123',
          //profile_image: userData.profile_image,
          username: userData.username,
          service_instance_id: userData.service_instance_id,
          cargo: userData.cargo,
          department: userData.department,
          //shift: userData.shift,
          status: userData.status,
          deleted: false
        };
        
        console.log("📤 Enviando dados para API:", formattedData);
    
        const response = await api.post('/users/', formattedData, {
          headers: {
            'Content-Type': 'application/json',
            'Authorization': `Bearer ${token}`
          },
        });
    
        console.log("✅ Resposta da API:", response.data);
    
        await this.fetchUsersHierarchy();
        return response.data;
      } catch (error) {
        console.error('❌ Erro ao criar usuário', error);
        throw error;
      } finally {
        this.loading = false;
      }
    },

   // Na função updateUser
    async updateUser(userId, userData) {
      try {
        this.loading = true;
        const authStore = useAuthStore();
        const token = authStore.token;

        // Formata os dados conforme o esperado pela API
        const formattedData = {
          username: userData.username,
          email: userData.email,
          profile_image: userData.profile_image,
          parent_id: userData.parent_id,
          service_instance_id: userData.service_instance_id,
          admission_date: userData.admission_date
            ? new Date(userData.admission_date).toISOString().split('T')[0]
            : null,
          ...(userData.password ? { password: userData.password } : {}),
          ...(userData.status_at !== undefined ? { status_at: userData.status_at } : {}),
          status: userData.status,
          cargo: userData.cargo,
          department: userData.department,
          //shift: userData.shift,
          status: userData.status,
        };

        console.log("📤 Enviando dados para API:", formattedData);

        const response = await api.put(`/users/${userId}`, formattedData, {
          headers: {
            'Content-Type': 'application/json',
            'Authorization': `Bearer ${token}`
          },
        });

        console.log("✅ Resposta da API:", response.data);

        await this.fetchUsersHierarchy();
        return response.data;
      } catch (error) {
        console.error('❌ Erro ao atualizar usuário', error);
        throw error;
      } finally {
        this.loading = false;
      }
    },

    async deleteUser(userId) {
      try {
        this.loading = true;
        const authStore = useAuthStore();
        const token = authStore.token;
    
        // Realiza o soft delete definindo o campo deleted como true
        const response = await api.delete(`/users/${userId}`, { deleted: true }, {
          headers: {
            'Content-Type': 'application/json',
            'Authorization': `Bearer ${token}`
          }
        });
    
        console.log("✅ Usuário deletado (soft delete):", response.data);
        
        // Retorna os dados atualizados
        return response.data;
      } catch (error) {
        console.error('Erro ao excluir usuário', error);
        throw error;
      } finally {
        this.loading = false;
      }
    },

    async fetchUserById(userId) {
      try {
        this.loading = true;
        const authStore = useAuthStore();
        const token = authStore.token; // Obtém o token de autenticação
        const response = await api.get(`/users/${userId}`, {
          headers: {
            'Authorization': `Bearer ${token}`
          }
        });
        this.user = response.data;
        return response.data;
      } catch (error) {
        console.error('Erro ao buscar dados do usuário', error);
        throw error;
      } finally {
        this.loading = false;
      }
    },

    async fetchFilteredUsers(filters = {}) {
      const {
        page = 1,
        per_page = 10,
        group_id,
        group_name,
        group_type,
        instance_id,
        space_id,
      } = filters;

      const queryParams = new URLSearchParams({
        page,
        per_page,
      });

      // Adiciona os filtros dinâmicos
      if (group_id) queryParams.append('group_id', group_id);
      if (group_name) queryParams.append('group_name', group_name);
      if (group_type) queryParams.append('group_type', group_type);
      if (instance_id) queryParams.append('instance_id', instance_id);
      if (space_id) queryParams.append('space_id', space_id);

      try {
        this.loading = true;
        const authStore = useAuthStore();
        const token = authStore.token; // Obtém o token de autenticação
        const response = await api.get(`/users/filter?${queryParams.toString()}`, {
          headers: {
            'Authorization': `Bearer ${token}`
          }
        });
        this.users = response.data.users.filter(user => !user.deleted); // Filtra usuários deletados
        this.pagination = {
          total: response.data.total,
          pages: response.data.pages,
          current_page: response.data.current_page,
          per_page: response.data.per_page,
        };
        return response.data;
      } catch (error) {
        console.error('Erro ao buscar usuários filtrados', error);
        throw error;
      } finally {
        this.loading = false;
      }
    },
  },
});
