module.exports = async function (fastify, opts) {
  // Inscription
  fastify.post('/register', {
    schema: {
      body: {
        type: 'object',
        required: ['email', 'password', 'name'],
        properties: {
          email: { type: 'string', format: 'email' },
          password: { type: 'string', minLength: 6 },
          name: { type: 'string' }
        }
      }
    }
  }, async (request, reply) => {
    const { email, password, name } = request.body;

    try {
      // Vérifier si l'utilisateur existe déjà
      const existingUser = await fastify.prisma.user.findUnique({
        where: { email }
      });

      if (existingUser) {
        return reply.code(400).send({ error: 'Cet email est déjà utilisé' });
      }

      // Créer un client Stripe
      const customer = await fastify.createCustomer(email, name);

      // Hacher le mot de passe
      const hashedPassword = await fastify.hashPassword(password);

      // Créer l'utilisateur
      const user = await fastify.prisma.user.create({
        data: {
          email,
          password: hashedPassword,
          name,
          stripeId: customer.id
        }
      });

      // Générer un token JWT
      const token = fastify.jwt.sign({ id: user.id }, { expiresIn: '7d' });

      return {
        user: {
          id: user.id,
          email: user.email,
          name: user.name,
          subscription: user.subscription
        },
        token
      };
    } catch (error) {
      fastify.log.error(error);
      return reply.code(500).send({ error: 'Erreur lors de l\'inscription' });
    }
  });

  // Connexion
  fastify.post('/login', {
    schema: {
      body: {
        type: 'object',
        required: ['email', 'password'],
        properties: {
          email: { type: 'string', format: 'email' },
          password: { type: 'string' }
        }
      }
    }
  }, async (request, reply) => {
    const { email, password } = request.body;

    try {
      // Trouver l'utilisateur
      const user = await fastify.prisma.user.findUnique({
        where: { email }
      });

      if (!user) {
        return reply.code(401).send({ error: 'Email ou mot de passe incorrect' });
      }

      // Vérifier le mot de passe
      const passwordMatch = await fastify.comparePassword(password, user.password);

      if (!passwordMatch) {
        return reply.code(401).send({ error: 'Email ou mot de passe incorrect' });
      }

      // Générer un token JWT
      const token = fastify.jwt.sign({ id: user.id }, { expiresIn: '7d' });

      return {
        user: {
          id: user.id,
          email: user.email,
          name: user.name,
          subscription: user.subscription
        },
        token
      };
    } catch (error) {
      fastify.log.error(error);
      return reply.code(500).send({ error: 'Erreur lors de la connexion' });
    }
  });

  fastify.post('/google-auth', {
    schema: {
      body: {
        type: 'object',
        required: ['token'],
        properties: {
          token: { type: 'string' }
        }
      }
    }
  }, async (request, reply) => {
    const { token } = request.body;

    try {
      // Utiliser le token d'accès pour obtenir les informations utilisateur
      // au lieu d'essayer de le vérifier comme un ID token
      const response = await fetch('https://www.googleapis.com/oauth2/v3/userinfo', {
        headers: { Authorization: `Bearer ${token}` }
      });

      if (!response.ok) {
        throw new Error('Impossible de récupérer les informations utilisateur');
      }

      const userData = await response.json();
      const { email, name, sub: googleId } = userData;

      // Vérifier si l'utilisateur existe déjà
      let user = await fastify.prisma.user.findUnique({
        where: { email }
      });

      if (!user) {
        // Créer un client Stripe
        const customer = await fastify.createCustomer(email, name);

        // Créer l'utilisateur
        user = await fastify.prisma.user.create({
          data: {
            email,
            name,
            googleId,
            stripeId: customer.id
          }
        });
      } else if (!user.googleId) {
        // Mettre à jour l'utilisateur existant avec l'ID Google
        user = await fastify.prisma.user.update({
          where: { id: user.id },
          data: { googleId }
        });
      }

      // Générer un token JWT
      const jwtToken = fastify.jwt.sign({ id: user.id }, { expiresIn: '7d' });

      return {
        user: {
          id: user.id,
          email: user.email,
          name: user.name,
          subscription: user.subscription
        },
        token: jwtToken
      };
    } catch (error) {
      fastify.log.error(error);
      return reply.code(500).send({ error: 'Erreur lors de l\'authentification Google' });
    }
  });
};