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 [loading, setLoading] = useState(true);
  const [error, setError] = useState<string | null>(null);

  useEffect(() => {
    fetchAuthors();
    fetchUsers();
  }, []);

  const fetchAuthors = async () => {
    try {
      setLoading(true);
      const fetchedAuthors = await authorService.getAuthors();
      setAuthors(fetchedAuthors);
      setError(null);
    } catch (err) {
      setError('Ошибка получения списка авторов');
      console.error('Ошибка получения списка авторов:', err);
    } finally {
      setLoading(false);
    }
  };

  const fetchUsers = async () => {
    try {
      setLoading(true);
      const fetchedUsers = await userService.getUsers();
      setUsers(fetchedUsers);
      setError(null);
    } catch (err) {
      setError('Ошибка получения списка авторов');
      console.error('Ошибка получения списка авторов:', err);
    } finally {
      setLoading(false);
    }
  };

  const createAuthor = async (formData: AuthorFormData) => {
    try {
      const newAuthor = await authorService.createAuthor(formData);
      setAuthors([...authors, newAuthor]);
      setError(null);
    } catch (err) {
      setError('Ошибка создания автора');
      throw err;
    }
  };

  const updateAuthor = async (authorId: string, formData: AuthorFormData) => {
    try {
      const updatedAuthor = await authorService.updateAuthor(authorId, formData);
      setAuthors(authors.map(author => author.id === authorId ? updatedAuthor : author));
      setError(null);
    } catch (err) {
      setError('Ошибка редакторования данных автора');
      throw err;
    }
  };

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

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

  const orderMoveUp = async (authorId: string) => {
    await authorService.reorderAuthor(authorId, 'up');
  };

  const orderMoveDown = async (authorId: string) => {
    await authorService.reorderAuthor(authorId, 'down');
  };

  const toggleActive = async (authorId: string, isActive: boolean) => {
    try {
      console.log(isActive);
      await authorService.toggleActive(authorId, isActive);
      setError(null);
    } catch (err) {
      setError('Ошибка отвязывания пользователя от автора');
      throw err;
    }
  };

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

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