import { useState, useEffect, useCallback } from 'react';
import { dataService } from '../services/dataService';
import { IRole } from '../types';
import { useUIStore } from '../store/useUIStore';

export const useRoles = () => {
  const [roles, setRoles] = useState<IRole[]>([]);
  const [permissionKeys, setPermissionKeys] = useState<string[]>([]);
  const [loading, setLoading] = useState(false);
  const [saving, setSaving] = useState(false);
  const { addNotification } = useUIStore();

  const loadRoles = useCallback(async () => {
    try {
      setLoading(true);
      const allRoles = await dataService.getAllRoles();
      setRoles(allRoles);
      
      const keys = await dataService.getPermissionKeys();
      setPermissionKeys(keys);
    } catch (error: any) {
      addNotification('error', error.message || 'Lỗi khi tải danh sách vai trò');
    } finally {
      setLoading(false);
    }
  }, [addNotification]);

  const createRole = useCallback(async (roleData: Partial<IRole>) => {
    try {
      setSaving(true);
      await dataService.createRole({
        name: roleData.name || '',
        code: roleData.code || '',
        description: roleData.description,
        permissions: roleData.permissions || {}
      });
      addNotification('success', 'Đã tạo vai trò thành công!');
      await loadRoles();
      return true;
    } catch (error: any) {
      addNotification('error', error.message || 'Lỗi khi tạo vai trò');
      return false;
    } finally {
      setSaving(false);
    }
  }, [addNotification, loadRoles]);

  const updateRole = useCallback(async (roleId: string, roleData: Partial<IRole>) => {
    try {
      setSaving(true);
      await dataService.updateRole(roleId, {
        name: roleData.name || '',
        code: roleData.code || '',
        description: roleData.description,
        permissions: roleData.permissions
      });
      addNotification('success', 'Đã cập nhật vai trò thành công!');
      await loadRoles();
      return true;
    } catch (error: any) {
      addNotification('error', error.message || 'Lỗi khi cập nhật vai trò');
      return false;
    } finally {
      setSaving(false);
    }
  }, [addNotification, loadRoles]);

  const deleteRole = useCallback(async (roleId: string) => {
    try {
      setSaving(true);
      const role = roles.find(r => r._id === roleId);
      if (role?.isSystem) {
        addNotification('error', 'Không thể xóa vai trò hệ thống');
        return false;
      }

      await dataService.deleteRole(roleId, false);
      addNotification('success', 'Đã xóa vai trò thành công!');
      await loadRoles();
      return true;
    } catch (error: any) {
      addNotification('error', error.message || 'Lỗi khi xóa vai trò');
      return false;
    } finally {
      setSaving(false);
    }
  }, [roles, addNotification, loadRoles]);

  const togglePermission = useCallback(async (roleId: string, permKey: string) => {
    const role = roles.find(r => r._id === roleId);
    if (!role) return;

    const updatedPermissions = {
      ...role.permissions,
      [permKey]: !role.permissions[permKey]
    };

    // Optimistically update UI
    setRoles(prev => prev.map(r => 
      r._id === roleId ? { ...r, permissions: updatedPermissions } : r
    ));

    // Save to backend
    try {
      await dataService.updateRolePermissions(roleId, updatedPermissions);
    } catch (error: any) {
      // Revert on error
      setRoles(prev => prev.map(r => 
        r._id === roleId ? { ...r, permissions: role.permissions } : r
      ));
      addNotification('error', error.message || 'Lỗi khi cập nhật quyền');
    }
  }, [roles, addNotification]);

  const saveAllPermissions = useCallback(async () => {
    try {
      setSaving(true);
      for (const role of roles) {
        await dataService.updateRolePermissions(role._id, role.permissions);
      }
      addNotification('success', 'Đã cập nhật phân quyền thành công!');
      await loadRoles();
    } catch (error: any) {
      addNotification('error', error.message || 'Lỗi khi cập nhật phân quyền');
    } finally {
      setSaving(false);
    }
  }, [roles, addNotification, loadRoles]);

  return {
    roles,
    permissionKeys,
    loading,
    saving,
    setRoles,
    loadRoles,
    createRole,
    updateRole,
    deleteRole,
    togglePermission,
    saveAllPermissions
  };
};