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

export interface User {
  id: string;
  name: string;
  email: string;
  avatarInitials: string;
  avatarColor: string;
  isCreator: boolean;
  enrolledCourseIds: string[];
  likedVideoIds: string[];
  bookmarkedVideoIds: string[];
  courseProgress: Record<string, number>;
}

interface AuthContextType {
  user: User | null;
  isAuthenticated: boolean;
  isLoading: boolean;
  login: (email: string, password: string) => Promise<void>;
  register: (name: string, email: string, password: string, isCreator: boolean) => Promise<void>;
  logout: () => Promise<void>;
  switchRole: (isCreator: boolean) => Promise<void>;
  enrollCourse: (courseId: string) => void;
  toggleLike: (videoId: string) => void;
  toggleBookmark: (videoId: string) => void;
  updateProgress: (courseId: string, progress: number) => void;
}

const AuthContext = createContext<AuthContextType | null>(null);
const STORAGE_KEY = '@ccollege:user';

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

  useEffect(() => {
    AsyncStorage.getItem(STORAGE_KEY)
      .then((stored) => { if (stored) setUser(JSON.parse(stored)); })
      .catch(() => {})
      .finally(() => setIsLoading(false));
  }, []);

  const saveUser = useCallback(async (u: User | null) => {
    setUser(u);
    if (u) await AsyncStorage.setItem(STORAGE_KEY, JSON.stringify(u));
    else await AsyncStorage.removeItem(STORAGE_KEY);
  }, []);

  const login = useCallback(async (email: string, _pw: string) => {
    const isDemo = email === 'demo@chinaskills.co.za';
    const name = isDemo ? 'Demo Creator' : email.split('@')[0];
    await saveUser({
      id: Date.now().toString(),
      name, email,
      avatarInitials: isDemo ? 'DC' : name.slice(0, 2).toUpperCase(),
      avatarColor: isDemo ? '#FF3CAC' : '#FF6B35',
      isCreator: isDemo,
      enrolledCourseIds: [],
      likedVideoIds: [],
      bookmarkedVideoIds: [],
      courseProgress: {},
    });
  }, [saveUser]);

  const register = useCallback(async (name: string, email: string, _pw: string, isCreator: boolean) => {
    const words = name.trim().split(' ');
    const initials = words.length >= 2
      ? (words[0][0] + words[words.length - 1][0]).toUpperCase()
      : name.slice(0, 2).toUpperCase();
    await saveUser({
      id: Date.now().toString(),
      name, email,
      avatarInitials: initials,
      avatarColor: isCreator ? '#FF3CAC' : '#FF6B35',
      isCreator,
      enrolledCourseIds: [],
      likedVideoIds: [],
      bookmarkedVideoIds: [],
      courseProgress: {},
    });
  }, [saveUser]);

  const logout = useCallback(async () => { await saveUser(null); }, [saveUser]);

  const switchRole = useCallback(async (newIsCreator: boolean) => {
    if (!user) return;
    await saveUser({ ...user, isCreator: newIsCreator, avatarColor: newIsCreator ? '#FF3CAC' : '#FF6B35' });
  }, [user, saveUser]);

  const enrollCourse = useCallback((courseId: string) => {
    if (!user) return;
    saveUser({
      ...user,
      enrolledCourseIds: [...new Set([...user.enrolledCourseIds, courseId])],
      courseProgress: { ...user.courseProgress, [courseId]: user.courseProgress[courseId] ?? 5 },
    });
  }, [user, saveUser]);

  const toggleLike = useCallback((videoId: string) => {
    if (!user) return;
    const isLiked = user.likedVideoIds.includes(videoId);
    saveUser({
      ...user,
      likedVideoIds: isLiked
        ? user.likedVideoIds.filter((id) => id !== videoId)
        : [...user.likedVideoIds, videoId],
    });
  }, [user, saveUser]);

  const toggleBookmark = useCallback((videoId: string) => {
    if (!user) return;
    const isB = user.bookmarkedVideoIds.includes(videoId);
    saveUser({
      ...user,
      bookmarkedVideoIds: isB
        ? user.bookmarkedVideoIds.filter((id) => id !== videoId)
        : [...user.bookmarkedVideoIds, videoId],
    });
  }, [user, saveUser]);

  const updateProgress = useCallback((courseId: string, progress: number) => {
    if (!user) return;
    saveUser({ ...user, courseProgress: { ...user.courseProgress, [courseId]: progress } });
  }, [user, saveUser]);

  return (
    <AuthContext.Provider value={{
      user, isAuthenticated: !!user, isLoading,
      login, register, logout, switchRole, enrollCourse, toggleLike, toggleBookmark, updateProgress,
    }}>
      {children}
    </AuthContext.Provider>
  );
}

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