text: 'use strict';
  
  const passport = require('koa-passport');
  const compose = require('koa-compose');
  
  const {
    validateRegistrationInput,
    validateAdminRegistrationInput,
    validateRegistrationInfoQuery,
    validateForgotPasswordInput,
    validateResetPasswordInput,
  } = require('../validation/authentication');
  
  module.exports = {
    login: compose([
      (ctx, next) => {
      console.log("kaljshdf");
        return passport.authenticate('local', { session: false }, (err, user, info) => {
          console.log("error", err);
          if (err) {
            strapi.eventHub.emit('admin.auth.error', { error: err, provider: 'local' });
            return ctx.badImplementation();
          }
          console.log("user", user);
          if (!user) {
            strapi.eventHub.emit('admin.auth.error', {
              error: new Error(info.message),
              provider: 'local',
            });
            return ctx.badRequest(info.message);
          }
  
          console.log("info", info);
          ctx.state.user = user;
  
          strapi.eventHub.emit('admin.auth.success', { user, provider: 'local' });
          console.log("success")
          return next();
        })(ctx, next);
      },
      ctx => {
        const { user } = ctx.state;
  
        ctx.body = {
          data: {
            token: strapi.admin.services.token.createJwtToken(user),
            user: strapi.admin.services.user.sanitizeUser(ctx.state.user), // TODO: fetch more detailed info
          },
        };
      },
    ]),
  
    async renewToken(ctx) {
      const {token} = ctx.request.body;
  
      if (token === undefined) {
        return ctx.badRequest('Missing token');
      }
  
      const {isValid, payload} = await strapi.admin.services.token.decodeJwtToken(token);
  
      if (!isValid) {
        return ctx.badRequest('Invalid token');
      }
  
      ctx.body = {
        data: {
          token: strapi.admin.services.token.createJwtToken({id: payload.id, email: payload.email}),
        },
      };
    },
  
    async registrationInfo(ctx) {
      try {
        await validateRegistrationInfoQuery(ctx.request.query);
      } catch (err) {
        return ctx.badRequest('QueryError', err);
      }
  
      const { registrationToken } = ctx.request.query;
  
      const registrationInfo = await strapi.admin.services.user.findRegistrationInfo(
        registrationToken
      );
  
      if (!registrationInfo) {
        return ctx.badRequest('Invalid registrationToken');
      }
  
      ctx.body = { data: registrationInfo };
    },
  
    async register(ctx) {
      const input = ctx.request.body;
  
      try {
        await validateRegistrationInput(input);
      } catch (err) {
        return ctx.badRequest('ValidationError', err);
      }
  
      const user = await strapi.admin.services.user.register(input);
  
      ctx.body = {
        data: {
          token: strapi.admin.services.token.createJwtToken(user),
          user: strapi.admin.services.user.sanitizeUser(user),
        },
      };
    },
  
    async registerAdmin(ctx) {
      const input = ctx.request.body;
  
      try {
        await validateAdminRegistrationInput(input);
      } catch (err) {
        return ctx.badRequest('ValidationError', err);
      }
  
      const hasAdmin = await strapi.admin.services.user.exists();
  
      if (hasAdmin) {
        return ctx.badRequest('You cannot register a new super admin');
      }
  
      const superAdminRole = await strapi.admin.services.role.getSuperAdmin();
  
      if (!superAdminRole) {
        throw new Error(
          "Cannot register the first admin because the super admin role doesn't exist."
        );
      }
  
      const user = await strapi.admin.services.user.create({
        ...input,
        registrationToken: null,
        isActive: true,
        roles: superAdminRole ? [superAdminRole.id] : [],
      });
  
      // await strapi.telemetry.send('didCreateFirstAdmin');
  
      ctx.body = {
        data: {
          token: strapi.admin.services.token.createJwtToken(user),
          user: strapi.admin.services.user.sanitizeUser(user),
        },
      };
    },
  
    async forgotPassword(ctx) {
      const input = ctx.request.body;
  
      try {
        await validateForgotPasswordInput(input);
      } catch (err) {
        return ctx.badRequest('ValidationError', err);
      }
  
      strapi.admin.services.auth.forgotPassword(input);
  
      ctx.status = 204;
    },
  
    async resetPassword(ctx) {
      const input = ctx.request.body;
  
      try {
        await validateResetPasswordInput(input);
      } catch (err) {
        return ctx.badRequest('ValidationError', err);
      }
  
      const user = await strapi.admin.services.auth.resetPassword(input);
  
      ctx.body = {
        data: {
          token: strapi.admin.services.token.createJwtToken(user),
          user: strapi.admin.services.user.sanitizeUser(user),
        },
      };
    },
  };
  