import React, { createContext, useContext, useEffect, useState, useCallback } from "react";
import axios from "axios";
import { toast } from "sonner";
import { supabase } from "../supabaseClient";
import { normalizeWhatsAppNumber } from "../utils/validators";
import { API_BASE_URL } from "../constants/api";

const AuthContext = createContext(null);

export function mapSupabaseAuthError(error) {
  if (!error) return "An unexpected error occurred. Please try again.";
  const msg = (error.message || "").toLowerCase();

  if (msg.includes("user already registered"))
    return "An account with this email already exists. Try signing in instead.";
  if (msg.includes("email rate limit") || msg.includes("over_email_send_rate_limit"))
    return "Too many signup attempts. Please wait a few minutes before trying again.";
  if (msg.includes("signup is disabled") || msg.includes("signups not allowed"))
    return "New signups are currently disabled. Please contact support.";
  if (msg.includes("email already in use") || msg.includes("email taken"))
    return "This email is already registered. Please sign in or use a different email.";
  if (msg.includes("password should be at least"))
    return "Your password is too short. Please use at least 8 characters.";
  if (msg.includes("unable to validate email address"))
    return "This email address doesn't appear to be valid.";

  if (msg.includes("invalid login credentials") || msg.includes("invalid credentials"))
    return "Incorrect email or password. Please try again.";
  if (msg.includes("email not confirmed"))
    return "Please confirm your email before signing in. Check your inbox.";
  if (msg.includes("too many requests") || msg.includes("rate limit"))
    return "Too many attempts. Please wait a moment and try again.";

  return error.message || "An unexpected error occurred. Please try again.";
}

export function AuthProvider({ children }) {
  const [session, setSession] = useState(null);
  const [profile, setProfile] = useState(null);
  const [loading, setLoading] = useState(true);

  const fetchProfile = useCallback(async (userId) => {
    if (!userId) {
      setProfile(null);
      return;
    }
    const { data, error } = await supabase
      .from("profiles")
      .select("*")
      .eq("id", userId)
      .maybeSingle();

    if (error) {
      console.warn("[AuthContext] fetchProfile failed:", error.code, error.message);
      setProfile(null);
    } else {
      setProfile(data ?? null);
    }
  }, []);

  useEffect(() => {
    supabase.auth.getSession().then(({ data: { session } }) => {
      setSession(session);
      if (session?.user) fetchProfile(session.user.id);
      setLoading(false);
    });

    const { data: listener } = supabase.auth.onAuthStateChange((_event, session) => {
      setSession(session);
      if (session?.user) {
        fetchProfile(session.user.id);
      } else {
        setProfile(null);
      }
    });

    return () => listener.subscription.unsubscribe();
  }, [fetchProfile]);

  const createProfile = async ({ userId, fullName, username, email, whatsappNumber }) => {
    const normalized = whatsappNumber ? normalizeWhatsAppNumber(whatsappNumber) : null;
    const payload = {
      id: userId,
      full_name: fullName,
      username,
      email,
      whatsapp_number: normalized ?? whatsappNumber ?? null,
    };

    const { data, error } = await supabase
      .from("profiles")
      .upsert(payload)
      .select()
      .maybeSingle();

    if (error) {
      console.error("[AuthContext] Profile upsert FAILED:", error.message);
    } else {
      setProfile(data);
    }
  };

  const sendWelcomeWhatsApp = async (whatsappNumber) => {
    const normalized = normalizeWhatsAppNumber(whatsappNumber);
    if (!normalized) return;
    try {
      await axios.post(`${API_BASE_URL}/whatsapp/welcome`, { phone: normalized });
    } catch (e) {
      console.warn("[AuthContext] Welcome WhatsApp failed:", e.message);
    }
  };

  const signUp = async ({ fullName, username, email, password, whatsappNumber }) => {
    const { data, error } = await supabase.auth.signUp({
      email,
      password,
      options: {
        data: {
          full_name: fullName,
          username,
          whatsapp_number: normalizeWhatsAppNumber(whatsappNumber) ?? whatsappNumber,
        },
      },
    });

    if (error) {
      const formattedErr = mapSupabaseAuthError(error);
      toast.error(formattedErr);
      return { success: false, error };
    }

    if (data.session) {
      await createProfile({
        userId: data.user.id,
        fullName,
        username,
        email,
        whatsappNumber,
      });
      await fetchProfile(data.user.id);
      sendWelcomeWhatsApp(whatsappNumber);
      toast.success("Account created successfully!");
    } else {
      toast.info("Signup successful! Please check your email to confirm registration.");
    }

    return { success: true, data };
  };

  const signIn = async (email, password, rememberMe = true) => {
    if (!rememberMe) {
      sessionStorage.setItem("tm_no_persist", "1");
    } else {
      sessionStorage.removeItem("tm_no_persist");
    }

    const { data, error } = await supabase.auth.signInWithPassword({ email, password });

    if (error) {
      const formattedErr = mapSupabaseAuthError(error);
      toast.error(formattedErr);
      return { data: null, error };
    }

    if (data.user) {
      const { data: existing } = await supabase
        .from("profiles")
        .select("id")
        .eq("id", data.user.id)
        .maybeSingle();

      if (!existing) {
        await createProfile({
          userId: data.user.id,
          fullName: data.user.user_metadata?.full_name ?? "",
          username: data.user.user_metadata?.username ?? "",
          email: data.user.email ?? email,
          whatsappNumber: data.user.user_metadata?.whatsapp_number ?? "",
        });
      }
      toast.success("Signed in successfully");
    }

    return { data, error: null };
  };

  const signOut = async () => {
    sessionStorage.removeItem("tm_no_persist");
    await supabase.auth.signOut();
    toast.info("Signed out");
  };

  const forgotPassword = async (email) => {
    const res = await supabase.auth.resetPasswordForEmail(email, {
      redirectTo: window.location.origin,
    });
    if (res.error) {
      toast.error(mapSupabaseAuthError(res.error));
    } else {
      toast.success("Password reset email sent");
    }
    return res;
  };

  const updatePassword = async (password) => {
    const res = await supabase.auth.updateUser({ password });
    if (res.error) {
      toast.error(mapSupabaseAuthError(res.error));
    } else {
      toast.success("Password updated successfully");
    }
    return res;
  };

  const updateProfile = async (fields) => {
    if (!session?.user) return { error: new Error("Not signed in") };
    const { data, error } = await supabase
      .from("profiles")
      .update(fields)
      .eq("id", session.user.id)
      .select()
      .single();
    if (!error) {
      setProfile(data);
      toast.success("Profile updated");
    } else {
      toast.error("Failed to update profile");
    }
    return { data, error };
  };

  const refreshProfile = async () => {
    if (session?.user) await fetchProfile(session.user.id);
  };

  const value = {
    session,
    user: session?.user ?? null,
    profile,
    loading,
    isAuthenticated: !!session,

    signIn,
    signUp,
    signOut,

    forgotPassword,
    updatePassword,

    updateProfile,
    refreshProfile,
  };

  return <AuthContext.Provider value={value}>{children}</AuthContext.Provider>;
}

export function useAuth() {
  const ctx = useContext(AuthContext);
  if (!ctx) throw new Error("useAuth() must be used inside <AuthProvider>");
  return ctx;
}