// stores/user.ts
import { defineStore } from "pinia";
import { ref, computed } from "vue";
import { useRouter } from "vue-router";
import axios from "axios";

interface User {
  id: number;
  first_name: string;
  last_name: string;
  email: string;
  phone?: string | null;
  user_role: string;
  is_active: boolean;
  last_login?: string | null;
  locked_until?: string | null;
  failed_login_attempts: number;
  password_reset_required: boolean;
  email_verified_at?: string | null;
}

export const useUserStore = defineStore("user", () => {
  const router = useRouter();

  // ❌ REMOVED: const ability = useAbility() - This caused the recursion!

  // State
  const user = ref<User | null>(null);
  const accessToken = ref<string | null>(null);
  const abilityRules = ref<string[]>([]);

  const isLoading = ref(false);
  const isLoaded = ref(false);
  const error = ref<string | null>(null);

  // Cookies
  const accessTokenCookie = useCookie("accessToken");
  const userAbilityRulesCookie = useCookie<string[]>("userAbilityRules");

  // Computed
  const isLoggedIn = computed(() => !!user.value?.id && !!accessToken.value);
  const isAuthenticated = computed(() => isLoggedIn.value);
  const token = computed(() => accessToken.value);

  const displayName = computed(() => {
    if (!user.value) return "";
    return user.value.first_name && user.value.last_name
      ? `${user.value.first_name} ${user.value.last_name}`
      : user.value.email || "";
  });

  const userRole = computed(() => user.value?.user_role || "");

  const isAdmin = computed(() =>
    ["Admin", "SystemOwner"].includes(userRole.value),
  );
  const isFinance = computed(() => userRole.value === "Finance");
  const isShareholder = computed(() => userRole.value === "Shareholder");

  const hasPermission = (permission: string) =>
    abilityRules.value.includes(permission);

  // Initialize from localStorage
  const init = () => {
    console.log("🔄 Initializing user store...");

    // Restore user data
    const savedUser = localStorage.getItem("user-data");
    if (savedUser) {
      try {
        user.value = JSON.parse(savedUser);
        console.log("✅ Restored user from localStorage:", user.value?.id);
      } catch (e) {
        console.error("Failed to restore user:", e);
        localStorage.removeItem("user-data");
      }
    }

    // Restore isLoaded state
    const savedLoaded = localStorage.getItem("user-loaded");
    if (savedLoaded) {
      try {
        isLoaded.value = JSON.parse(savedLoaded);
      } catch (e) {
        isLoaded.value = false;
      }
    }

    // Token from localStorage
    const token = localStorage.getItem("accessToken");
    if (token) {
      accessToken.value = token;
      accessTokenCookie.value = token;
    }

    // Restore abilityRules from cookie
    if (
      userAbilityRulesCookie.value &&
      Array.isArray(userAbilityRulesCookie.value)
    ) {
      abilityRules.value = userAbilityRulesCookie.value;
    }

    console.log("✅ User store initialized:", {
      hasUser: !!user.value,
      isLoaded: isLoaded.value,
      hasToken: !!accessToken.value,
    });
  };

  init();

  // Manual persistence functions (NO WATCHERS)
  const persistUserData = () => {
    if (!user.value) {
      localStorage.removeItem("user-data");
      localStorage.removeItem("user-loaded");
      return;
    }

    try {
      // Only save clean primitives
      const cleanUser = {
        id: user.value.id,
        first_name: user.value.first_name,
        last_name: user.value.last_name,
        email: user.value.email,
        phone: user.value.phone,
        user_role: user.value.user_role,
        is_active: user.value.is_active,
        last_login: user.value.last_login,
        locked_until: user.value.locked_until,
        failed_login_attempts: user.value.failed_login_attempts,
        password_reset_required: user.value.password_reset_required,
        email_verified_at: user.value.email_verified_at,
      };

      localStorage.setItem("user-data", JSON.stringify(cleanUser));
      localStorage.setItem("user-loaded", JSON.stringify(isLoaded.value));
    } catch (err) {
      console.error("❌ Failed to persist user data:", err);
    }
  };

  // Actions
  const setUser = (userData: User, rules: string[], token: string) => {
    // Create clean user object
    user.value = {
      id: userData.id,
      first_name: userData.first_name,
      last_name: userData.last_name,
      email: userData.email,
      phone: userData.phone,
      user_role: userData.user_role,
      is_active: userData.is_active,
      last_login: userData.last_login,
      locked_until: userData.locked_until,
      failed_login_attempts: userData.failed_login_attempts,
      password_reset_required: userData.password_reset_required,
      email_verified_at: userData.email_verified_at,
    };

    abilityRules.value = rules;
    userAbilityRulesCookie.value = rules;

    accessToken.value = token;
    localStorage.setItem("accessToken", token);
    accessTokenCookie.value = token;

    isLoaded.value = true;
    error.value = null;

    // Manual persist
    persistUserData();

    console.log("✅ User set in store:", {
      userId: user.value.id,
      role: user.value.user_role,
      rules: rules.length,
    });
  };

  const clearUser = () => {
    console.log("🧹 Clearing user data");

    user.value = null;
    abilityRules.value = [];

    accessToken.value = null;
    localStorage.removeItem("accessToken");
    localStorage.removeItem("user-data");
    localStorage.removeItem("user-loaded");
    accessTokenCookie.value = null;
    userAbilityRulesCookie.value = null;

    isLoaded.value = false;
    error.value = null;
  };

  const login = async (credentials: {
    email: string;
    password: string;
    remember_me?: boolean;
  }) => {
    isLoading.value = true;
    error.value = null;

    try {
      const { data } = await axios.post("/api/login", credentials);
      const { accessToken, userData, userAbilityRules } = data;

      setUser(userData, userAbilityRules || [], accessToken);

      // ✅ Return the rules so component can update CASL
      return {
        ...data,
        userAbilityRules: userAbilityRules || [],
      };
    } catch (err: any) {
      error.value = err.response?.data?.message || "Login failed";
      throw err;
    } finally {
      isLoading.value = false;
    }
  };

  const fetchUser = async () => {
    // Don't fetch if on error pages
    if (
      window.location.pathname === "/account-error" ||
      window.location.pathname === "/login"
    ) {
      console.log("⚠️ On error/login page, skipping user fetch");
      return null;
    }

    if (isLoaded.value && user.value) {
      console.log("✅ User already loaded, returning cached data");
      return user.value;
    }

    if (!accessToken.value) {
      clearUser();
      return null;
    }

    isLoading.value = true;
    try {
      const { data } = await axios.get("/api/user");

      // Create clean user object
      user.value = {
        id: data.id,
        first_name: data.first_name,
        last_name: data.last_name,
        email: data.email,
        phone: data.phone,
        user_role: data.user_role,
        is_active: data.is_active,
        last_login: data.last_login,
        locked_until: data.locked_until,
        failed_login_attempts: data.failed_login_attempts,
        password_reset_required: data.password_reset_required,
        email_verified_at: data.email_verified_at,
      };

      isLoaded.value = true;

      // Manual persist
      persistUserData();

      console.log("✅ User fetched from API:", user.value.id);
      return user.value;
    } catch (err: any) {
      if (err.response?.status === 401) {
        await logout();
      }
      error.value = err.response?.data?.message || "Failed to load user";
      throw err;
    } finally {
      isLoading.value = false;
    }
  };

  const logout = async () => {
    try {
      await axios.post("/api/logout");
    } catch (err) {
      console.warn("Logout request failed", err);
    } finally {
      clearUser();
      router.push({ name: "login" });
    }
  };

  return {
    user,
    accessToken,
    abilityRules,
    isLoading,
    isLoaded,
    error,

    isLoggedIn,
    isAuthenticated,
    token,
    displayName,
    userRole,
    isAdmin,
    isFinance,
    isShareholder,
    hasPermission,

    setUser,
    clearUser,
    login,
    fetchUser,
    logout,
  };
});