import { PrismaClient } from '@prisma/client';
import bcrypt from 'bcryptjs';
import jwt from 'jsonwebtoken';
import { User } from '../../src/types/auth.js';
import { logger } from '../config/logger.js';

const prisma = new PrismaClient();

export const authService = {
  login: async (email: string, password: string) => {
    try {
      logger.info(`Login attempt for user: ${email}`);
      
      const user = await prisma.user.findUnique({
        where: { email },
        select: {
          id: true,
          email: true,
          password: true,
          displayName: true,
          permissions: true
        }
      });

      if (!user) {
        logger.warn(`Login failed: User not found - ${email}`);
        throw new Error('Invalid credentials');
      }

      const isValidPassword = await bcrypt.compare(password, user.password);
      if (!isValidPassword) {
        logger.warn(`Login failed: Invalid password for user - ${email}`);
        throw new Error('Invalid credentials');
      }

      const token = await authService.generateToken(user.id);
      const { password: _, ...userWithoutPassword } = user;
      
      logger.info(`User logged in successfully: ${email}`);
      return {
        user: userWithoutPassword as User,
        token
      };
    } catch (error) {
      logger.error('Login error:', error);
      throw error;
    }
  },

  generateToken: async (userId: string) => {
    try {
      const token = jwt.sign(
        { id: userId },
        process.env.JWT_SECRET || '',
        { expiresIn: '24h' }
      );
      logger.debug(`Generated token for user: ${userId}`);
      return token;
    } catch (error) {
      logger.error('Token generation error:', error);
      throw error;
    }
  },

  createUser: async (userData: {
    email: string;
    password: string;
    displayName: string;
    permissions: any;
  }) => {
    try {
      logger.info(`Creating new user: ${userData.email}`);
      
      const hashedPassword = await bcrypt.hash(userData.password, 10);
      const user = await prisma.user.create({
        data: {
          ...userData,
          password: hashedPassword
        },
        select: {
          id: true,
          email: true,
          displayName: true,
          permissions: true
        }
      });

      logger.info(`User created successfully: ${userData.email}`);
      return user as User;
    } catch (error) {
      logger.error('User creation error:', error);
      throw error;
    }
  }
};