import React, { createContext, useContext, useState, useEffect, ReactNode } from 'react';
import AsyncStorage from '@react-native-async-storage/async-storage';
import { api } from '../services/api';

interface User {
  id: string;
  email: string;
  name: string;
  role: string;
  height_cm?: number;
  weight_kg?: number;
  age?: number;
  gender?: string;
  calorie_target?: number;
  protein_target?: number;
  fiber_target?: number;
  fat_target?: number;
  profile_photo?: string;
  bmi?: number;
  bmr?: number;
}

interface AuthContextType {
  user: User | null;
  token: string | null;
  isLoading: boolean;
  isAuthenticated: boolean;
  isAdmin: boolean;
  login: (email: string, password: string) => Promise<{ success: boolean; error?: string }>;
  logout: () => Promise<void>;
  refreshUser: () => Promise<void>;
}

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

export function AuthProvider({ children }: { children: ReactNode }) {
  const [user, setUser] = useState<User | null>(null);
  const [token, setToken] = useState<string | null>(null);
  const [isLoading, setIsLoading] = useState(true);

  useEffect(() => {
    loadStoredAuth();
  }, []);

  const loadStoredAuth = async () => {
    try {
      const storedToken = await AsyncStorage.getItem('token');
      const storedUser = await AsyncStorage.getItem('user');
      
      if (storedToken && storedUser) {
        setToken(storedToken);
        setUser(JSON.parse(storedUser));
        api.setToken(storedToken);
      }
    } catch (error) {
      console.error('Error loading auth:', error);
    } finally {
      setIsLoading(false);
    }
  };

  const login = async (email: string, password: string): Promise<{ success: boolean; error?: string }> => {
    try {
      console.log('[Auth] Attempting login for:', email);
      const response = await api.login(email, password);
      console.log('[Auth] Login response received:', response);
      
      if (response.access_token) {
        await AsyncStorage.setItem('token', response.access_token);
        await AsyncStorage.setItem('user', JSON.stringify(response.user));
        
        setToken(response.access_token);
        setUser(response.user);
        api.setToken(response.access_token);
        
        console.log('[Auth] Login successful, user role:', response.user?.role);
        return { success: true };
      }
      console.log('[Auth] No access token in response');
      return { success: false, error: 'Invalid response from server' };
    } catch (error: any) {
      console.error('[Auth] Login error:', error);
      console.error('[Auth] Error details:', error.response?.status, error.response?.data);
      return { success: false, error: error.response?.data?.detail || 'Login failed' };
    }
  };

  const logout = async () => {
    await AsyncStorage.removeItem('token');
    await AsyncStorage.removeItem('user');
    setToken(null);
    setUser(null);
    api.setToken(null);
  };

  const refreshUser = async () => {
    try {
      if (token) {
        const userData = await api.getMe();
        setUser(userData);
        await AsyncStorage.setItem('user', JSON.stringify(userData));
      }
    } catch (error) {
      console.error('Error refreshing user:', error);
    }
  };

  return (
    <AuthContext.Provider
      value={{
        user,
        token,
        isLoading,
        isAuthenticated: !!token,
        isAdmin: user?.role === 'admin',
        login,
        logout,
        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;
}