import { useState, useEffect } from 'react';
import { Author, AuthorFormData, User } from '../types/auth';
import { authorService } from '../services/authorService';
import { userService } from '../services/userService';

export function useAuthorManagement() {
  const [authors, setAuthors] = useState<Author[]>([]);
  const [users, setUsers] = useState<User[]>([]);
  const [selectedAuthor, setSelectedAuthor] = useState<Author | null>(null);
  const [selectedRole, setSelectedRole] = useState<string>('');
  const [loading, setLoading] = useState(false);
  const [error, setError] = useState<string | null>(null);
  const [currentPage, setCurrentPage] = useState(1);
  const [totalPages, setTotalPages] = useState(1);

  // --- Загрузка авторов и пользователей ---
  useEffect(() => {
    void fetchAuthors(selectedRole, currentPage);
    void fetchUsers();
  }, [selectedRole, currentPage]);

  // --- Получение списка авторов ---
  const fetchAuthors = async (role: string, page: number) => {
    try {
      setLoading(true);
      const response = await authorService.getAuthors(role, page);
      setAuthors(response.authors ?? []); // защита от undefined
      setTotalPages(response.totalPages ?? 1);
      setError(null);
    } catch (err) {
      console.error('Ошибка получения списка авторов:', err);
      setError('Ошибка получения списка авторов');
    } finally {
      setLoading(false);
    }
  };

  // --- Получение списка пользователей ---
  const fetchUsers = async () => {
    try {
      const fetchedUsers = await userService.getUsers();
      setUsers(fetchedUsers ?? []);
      setError(null);
    } catch (err) {
      console.error('Ошибка получения списка пользователей:', err);
      setError('Ошибка получения списка пользователей');
    }
  };

  // --- Создание автора ---
  const createAuthor = async (formData: AuthorFormData) => {
    try {
      setLoading(true);
      const newAuthor = await authorService.createAuthor(formData);
      setAuthors(prev => [...prev, newAuthor]);
      setError(null);
    } catch (err) {
      console.error('Ошибка создания автора:', err);
      setError('Ошибка создания автора');
      throw err;
    } finally {
      setLoading(false);
    }
  };

  // --- Обновление автора ---
  const updateAuthor = async (authorId: string, formData: AuthorFormData) => {
    try {
      setLoading(true);
      const updatedAuthor = await authorService.updateAuthor(authorId, formData);
      setAuthors(prev =>
        prev.map(author => (author.id === authorId ? updatedAuthor : author))
      );
      setError(null);
    } catch (err) {
      console.error('Ошибка редактирования автора:', err);
      setError('Ошибка редактирования автора');
      throw err;
    } finally {
      setLoading(false);
    }
  };

  // --- Связывание пользователя с автором ---
  const linkUser = async (authorId: string, userId: string) => {
    try {
      await authorService.linkUser(authorId, userId);
      setError(null);
      await fetchAuthors(selectedRole, currentPage);
    } catch (err) {
      console.error('Ошибка связывания пользователя с автором:', err);
      setError('Ошибка связывания пользователя с автором');
      throw err;
    }
  };

  // --- Отвязка пользователя от автора ---
  const unlinkUser = async (authorId: string) => {
    try {
      await authorService.unlinkUser(authorId);
      setError(null);
      await fetchAuthors(selectedRole, currentPage);
    } catch (err) {
      console.error('Ошибка отвязывания пользователя от автора:', err);
      setError('Ошибка отвязывания пользователя от автора');
      throw err;
    }
  };

  // --- Перемещение автора вверх / вниз ---
  const orderMoveUp = async (authorId: string) => {
    try {
      await authorService.reorderAuthor(authorId, 'up');
      await fetchAuthors(selectedRole, currentPage);
    } catch (err) {
      console.error('Ошибка изменения порядка авторов (вверх):', err);
      setError('Ошибка изменения порядка авторов');
    }
  };

  const orderMoveDown = async (authorId: string) => {
    try {
      await authorService.reorderAuthor(authorId, 'down');
      await fetchAuthors(selectedRole, currentPage);
    } catch (err) {
      console.error('Ошибка изменения порядка авторов (вниз):', err);
      setError('Ошибка изменения порядка авторов');
    }
  };

  // --- Активация / деактивация автора ---
  const toggleActive = async (authorId: string, isActive: boolean) => {
    try {
      await authorService.toggleActive(authorId, isActive);
      setError(null);
      await fetchAuthors(selectedRole, currentPage);
    } catch (err) {
      console.error('Ошибка переключения активности автора:', err);
      setError('Ошибка изменения активности автора');
      throw err;
    }
  };

  // --- Удаление автора ---
  const deleteAuthor = async (authorId: string) => {
    try {
      await authorService.deleteAuthor(authorId);
      setAuthors(prev => prev.filter(author => author.id !== authorId));
      if (selectedAuthor?.id === authorId) {
        setSelectedAuthor(null);
      }
      setError(null);
    } catch (err) {
      console.error('Ошибка удаления автора:', err);
      setError('Ошибка удаления автора');
      throw err;
    }
  };

  return {
    authors,
    users,
    selectedAuthor,
    loading,
    error,
    selectedRole,
    currentPage,
    totalPages,
    setSelectedAuthor,
    createAuthor,
    updateAuthor,
    linkUser,
    unlinkUser,
    orderMoveUp,
    orderMoveDown,
    toggleActive,
    deleteAuthor,
    fetchAuthors,
    fetchUsers,
    setSelectedRole,
    setCurrentPage,
  };
}
