import { Response } from 'express';
import { AuthRequest } from '../../../middleware/auth';
import { userService } from '../../../services/userService';
import { logger } from '../../../config/logger';
import bcrypt from 'bcryptjs';
import { prisma } from '../../../lib/prisma';
import { getDefaultPermissions } from '../../../utils/permissions';


// Список пользователей
export async function getUsers(req: AuthRequest, res: Response): Promise<void> {
  try {
    // Проверка прав администратора
    if (!req.user?.permissions.isAdmin) {
      res.status(403).json({ error: 'Требуются права администратора' });
      return
    }

    const users = await userService.getUsers();
    res.json(users);
  } catch {
    res.status(500).json({ error: 'Серверная ошибка' });
  }
}

export async function createUser(req: AuthRequest, res: Response): Promise<void> {
  try {
    if (!req.user?.permissions.isAdmin) {
      logger.warn(`Не администратор ${req.user?.id} пытается создать пользователя`);
      res.status(403).json({ error: 'Требуются права администратора' });
      return
    }

    const { email, password, displayName, bio, avatarUrl } = req.body;

    // Проверка существования пользователя
    const existingUser = await prisma.user.findUnique({
      where: { email }
    });

    if (existingUser) {
      res.status(400).json({ error: 'Пользователь уже существует' });
      return
    }

    // Вычисление хеша пароля
    const hashedPassword = await bcrypt.hash(password, 10);

    // Создание пользователя с правами по умолчанию
    const user = await prisma.user.create({
      data: {
        email,
        password: hashedPassword,
        displayName,
        bio,
        avatarUrl,
        permissions: getDefaultPermissions()
      },
      select: {
        id: true,
        email: true,
        displayName: true,
        bio: true,
        avatarUrl: true,
        permissions: true
      }
    });

    logger.info(`Успашное создание пользователя: ${user.id}`);
    res.status(201).json(user);
  } catch (error) {
    logger.error('Ошибка создания пользователя:', error);
    res.status(500).json({ error: 'Ошибка создания пользователя' });
  }
}

export async function updateUser(req: AuthRequest, res: Response): Promise<void> {
  try {
    if (!req.user?.permissions.isAdmin) {
      logger.warn(`Не администратор ${req.user?.id} пытается обновить пользователя`);
      res.status(403).json({ error: 'Требуются права администратора' });
      return
    }

    const { id } = req.params;
    const { email, password, displayName, bio, avatarUrl } = req.body;

    // Проверка существования пользователя
    const existingUser = await prisma.user.findUnique({
      where: { id }
    });

    if (!existingUser) {
      res.status(404).json({ error: 'Пользователь не найден' });
      return
    }

    // Подготовка данных для изменения
    const updateData: any = {
      email,
      displayName,
      bio,
      avatarUrl
    };

    // Если требуется сменить пароль
    if (password) {
      updateData.password = await bcrypt.hash(password, 10);
    }

    // Обновление данных пользователя
    const user = await prisma.user.update({
      where: { id },
      data: updateData,
      select: {
        id: true,
        email: true,
        displayName: true,
        bio: true,
        avatarUrl: true,
        permissions: true
      }
    });

    logger.info(`Успешное обновление пользователя: ${user.id}`);
    res.json(user);
  } catch (error) {
    logger.error('Ошибка обновления пользователя:', error);
    res.status(500).json({ error: 'Ошибка обновления пользователя' });
  }
}

// Обновление прав пользователя
export async function updateUserPermissions(req: AuthRequest, res: Response): Promise<void> {
  try {
    // Проверка прав администратора
    if (!req.user?.permissions.isAdmin) {
      res.status(403).json({ error: 'Требуются права администратора' });
      return
    }

    // Извлечение параметров из запроса
    const { id } = req.params;
    const { permissions } = req.body;

    // Обновление прав пользователя
    const user = await userService.updateUserPermissions(id, permissions);
    res.json(user);
  } catch {
    res.status(500).json({ error: 'Серверная ошибка' });
  }
}

// Удаление пользователя
export async function deleteUser(req: AuthRequest, res: Response): Promise<void> {
  try {
    if (!req.user?.permissions.isAdmin) {
      logger.warn(`Не администратор ${req.user?.id} пытается удалить пользователя`);
      res.status(403).json({ error: 'Требуются права администратора' });
      return
    }

    const { id } = req.params;

    // Check if user exists
    const existingUser = await prisma.user.findUnique({
      where: { id }
    });

    if (!existingUser) {
      res.status(404).json({ error: 'Пользователь не найден' });
      return
    }

    // Delete user
    await prisma.user.delete({
      where: { id }
    });

    logger.info(`Успешное удаление пользователя: ${id}`);
    res.json({ message: 'Успешное удаление пользователя' });
  } catch (error) {
    logger.error('Ошибка удаления пользователя:', error);
    res.status(500).json({ error: 'Ошибка удаления пользователя' });
  }
}