import React, { createContext, useContext, useState, useEffect } from 'react';
import { authService } from '../services/authService';
import { DEMO_USER } from '../services/mockData';

const AuthContext = createContext();

export function AuthProvider({ children }) {
  const [user, setUser] = useState(null);
  const [token, setToken] = useState(null);
  const [loading, setLoading] = useState(true);
  const [isDemoMode, setIsDemoMode] = useState(false);

  useEffect(() => {
    // Restore session on mount
    try {
      const storedToken = localStorage.getItem('authsec_token');
      const storedUser = localStorage.getItem('authsec_user');
      if (storedToken && storedUser) {
        setToken(storedToken);
        setUser(JSON.parse(storedUser));
      }
    } catch (e) {
      console.error('Failed to parse stored session:', e);
      localStorage.removeItem('authsec_token');
      localStorage.removeItem('authsec_user');
    } finally {
      setLoading(false);
    }
  }, []);

  const login = async (email, password, forceMock = false) => {
    const res = await authService.login(email, password, forceMock);
    const item = res.item || res;
    const authToken = item.token || 'demo-token-' + Date.now();
    
    // Store in localStorage
    localStorage.setItem('authsec_token', authToken);
    localStorage.setItem('authsec_user', JSON.stringify(item));

    setToken(authToken);
    setUser(item);
    if (forceMock || res.operationMessage?.includes('Demo')) {
      setIsDemoMode(true);
    }
    return item;
  };

  const loginAsDemo = async () => {
    return login(DEMO_USER.email, 'admin123', true);
  };

  const logout = async () => {
    await authService.logout();
    setUser(null);
    setToken(null);
    setIsDemoMode(false);
  };

  const register = async (userData) => {
    return authService.registerUser(userData);
  };

  const value = {
    user,
    token,
    loading,
    isAuthenticated: !!token && !!user,
    isDemoMode,
    login,
    loginAsDemo,
    logout,
    register,
  };

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

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