import { createAsyncThunk, createSlice } from '@reduxjs/toolkit';
import type { PayloadAction } from '@reduxjs/toolkit';
import jwtAxios from '../../api/axiosInstance';
import { ENDPOINTS } from '../../api/endpoints';
import { ENV } from '../../config/env';
import type { LoginPayload, LoginResponse, User } from '../../types/auth.types';

type AuthState = {
  user: User | null;
  token: string | null;
  isAuthenticated: boolean;
  loading: boolean;
  error: string | null;
  authInitialized: boolean;
};

const initialState: AuthState = {
  user: null,
  token: null,
  isAuthenticated: false,
  loading: false,
  error: null,
  authInitialized: false,
};

const getStoredToken = () => {
  if (typeof window === 'undefined') {
    return null;
  }

  return localStorage.getItem(ENV.ACCESS_TOKEN_STORAGE_KEY);
};

const getStoredUser = () => {
  if (typeof window === 'undefined') {
    return null;
  }

  const storedUser = localStorage.getItem(ENV.USER_STORAGE_KEY);
  return storedUser ? JSON.parse(storedUser) as User : null;
};

export const loginUser = createAsyncThunk<LoginResponse, LoginPayload, { rejectValue: string }>(
  'auth/loginUser',
  async (payload, { rejectWithValue }) => {
    try {
      const response = await jwtAxios.post(ENDPOINTS.LOGIN, payload);
      const resData = (response.data as any)?.data || response.data;

      const token = resData?.accessToken || resData?.access_token || resData?.token;
      const user = resData?.user;

      if (!token) {
        return rejectWithValue(response.data?.message || 'Invalid response from server: Access token missing');
      }

      return {
        accessToken: token,
        user: user,
      };
    } catch (error: any) {
      const message = error?.response?.data?.message || error?.message || 'Login failed';
      return rejectWithValue(message);
    }
  }
);

const authSlice = createSlice({
  name: 'auth',
  initialState,
  reducers: {
    initializeAuth: (state) => {
      const token = getStoredToken();
      const user = getStoredUser();

      state.token = token;
      state.user = user;
      state.isAuthenticated = Boolean(token && user);
      state.authInitialized = true;
      state.error = null;
    },
    logout: (state) => {
      state.user = null;
      state.token = null;
      state.isAuthenticated = false;
      state.loading = false;
      state.error = null;
      state.authInitialized = true;

      if (typeof window !== 'undefined') {
        localStorage.removeItem(ENV.ACCESS_TOKEN_STORAGE_KEY);
        localStorage.removeItem(ENV.USER_STORAGE_KEY);
      }
    },
    clearError: (state) => {
      state.error = null;
    },
    updateUser: (state, action: PayloadAction<Partial<User>>) => {
      if (state.user) {
        state.user = { ...state.user, ...action.payload };
        if (typeof window !== 'undefined') {
          localStorage.setItem(ENV.USER_STORAGE_KEY, JSON.stringify(state.user));
        }
      }
    },
  },
  extraReducers: (builder) => {
    builder
      .addCase(loginUser.pending, (state) => {
        state.loading = true;
        state.error = null;
      })
      .addCase(loginUser.fulfilled, (state, action: PayloadAction<LoginResponse>) => {
        state.loading = false;
        state.user = action.payload.user;
        state.token = action.payload.accessToken;
        state.isAuthenticated = true;
        state.authInitialized = true;

        if (typeof window !== 'undefined') {
          localStorage.setItem(ENV.ACCESS_TOKEN_STORAGE_KEY, action.payload.accessToken);
          if (action.payload.user) {
            localStorage.setItem(ENV.USER_STORAGE_KEY, JSON.stringify(action.payload.user));
          }
        }
      })
      .addCase(loginUser.rejected, (state, action) => {
        state.loading = false;
        state.error = action.payload ?? 'Login failed';
        state.isAuthenticated = false;
      });
  },
});

export const { initializeAuth, logout, clearError, updateUser } = authSlice.actions;
export default authSlice.reducer;