'use client';

import React, { createContext, useContext, useState, useEffect } from 'react';
import { useRouter } from 'next/navigation';
import { apiRequest } from '@/lib/api';

interface Business {
  id: string;
  name: string;
  email: string;
  phone?: string;
  walletAddress?: string;
  status?: string;
  subscriptionPlan?: string;
  subscriptionStatus?: string;
  onboardingStep?: string;
  selectedPlan?: string;
  trialEnd?: string;
  createdAt?: string;
}

interface AuthContextType {
  user: Business | null;
  loading: boolean;
  token: string | null;
  login: (email: string, password: string, redirectTo?: string) => Promise<void>;
  register: (businessName: string, email: string, password: string, phone?: string, redirectTo?: string) => Promise<void>;
  logout: () => void;
  updateUser: (updatedUser: Business) => void;
  refreshUser: () => Promise<void>;
}

const AuthContext = createContext<AuthContextType | undefined>(undefined);

export function AuthProvider({ children }: { children: React.ReactNode }) {
  const [user, setUser] = useState<Business | null>(null);
  const [token, setToken] = useState<string | null>(null);
  const [loading, setLoading] = useState(true);
  const router = useRouter();

  const fetchLatestUser = async () => {
    try {
      const latestUser = await apiRequest<Business>('api/auth/me');
      if (latestUser && latestUser.id) {
        setUser(latestUser);
        localStorage.setItem('user', JSON.stringify(latestUser));
      }
    } catch (err) {
      console.error('Failed to sync user profile:', err);
    }
  };

  useEffect(() => {
    // Check if token exists in localStorage
    const savedToken = localStorage.getItem('token');
    const savedUser = localStorage.getItem('user');

    if (savedToken && savedUser) {
      setToken(savedToken);
      setUser(JSON.parse(savedUser));
    }

    if (savedToken) {
      fetchLatestUser().finally(() => setLoading(false));
    } else {
      setLoading(false);
    }
  }, []);

  const login = async (email: string, password: string, redirectTo?: string) => {
    setLoading(true);
    try {
      const data = await apiRequest('api/auth/login', 'POST', { email, password });
      localStorage.setItem('token', data.accessToken);
      localStorage.setItem('user', JSON.stringify(data.business));
      setToken(data.accessToken);
      setUser(data.business);
      router.push(redirectTo || '/dashboard');
    } finally {
      setLoading(false);
    }
  };

  const register = async (businessName: string, email: string, password: string, phone?: string, redirectTo?: string) => {
    setLoading(true);
    try {
      const storedPlan = localStorage.getItem('selectedPlan');
      const data = await apiRequest('api/auth/register', 'POST', {
        businessName,
        email,
        password,
        phone,
        selectedPlan: storedPlan || undefined,
      });
      localStorage.setItem('token', data.accessToken);
      localStorage.setItem('user', JSON.stringify(data.business));
      setToken(data.accessToken);
      setUser(data.business);
      router.push(redirectTo || '/dashboard');
    } finally {
      setLoading(false);
    }
  };

  const logout = () => {
    localStorage.removeItem('token');
    localStorage.removeItem('user');
    setToken(null);
    setUser(null);
    router.push('/login');
  };

  const updateUser = (updatedUser: Business) => {
    setUser(updatedUser);
    localStorage.setItem('user', JSON.stringify(updatedUser));
  };

  const refreshUser = async () => {
    await fetchLatestUser();
  };

  return (
    <AuthContext.Provider value={{ user, loading, token, login, register, logout, updateUser, refreshUser }}>
      {children}
    </AuthContext.Provider>
  );
}

export function useAuth() {
  const context = useContext(AuthContext);
  if (context === undefined) {
    throw new Error('useAuth must be used within an AuthProvider');
  }
  return context;
}