// dtp-sites-cli.js
// Copyright (C) 2021 Digital Telepresence, LLC
// License: Apache-2.0

'use strict';

const DTP_COMPONENT_NAME = 'sites-cli';

require('dotenv').config();

const path = require('path');

const mongoose = require('mongoose');

const {
  SitePlatform,
  SiteAsync,
  SiteLog,
} = require(path.join(__dirname, 'lib', 'site-lib'));

module.pkg = require(path.join(__dirname, 'package.json'));
module.config = {
  componentName: DTP_COMPONENT_NAME,
  root: __dirname,
  site: {
    name: process.env.DTP_SITE_NAME,
    description: process.env.DTP_SITE_DESCRIPTION,
    domain: process.env.DTP_SITE_DOMAIN,
    domainKey: process.env.DTP_SITE_DOMAIN_KEY,
    company: process.env.DTP_SITE_COMPANY || 'Digital Telepresence, LLC',
  },
};

module.log = new SiteLog(module, module.config.componentName);

module.grantPermission = async (target, permission) => {
  const User = mongoose.model('User');
  try {
    const user = await User.findOne({ email: target }).select('+permissions +flags');
    switch (permission) {
      case 'admin':
        user.flags.isAdmin = true;
        break;
      case 'moderator':
        user.flags.isModerator = true;
        break;
      case 'login':
        user.permissions.canLogin = true;
        break;
      default:
        throw new Error(`Invalid permission: ${permission}`);
    }
    await user.save();
    module.log.info('user updated', { user: user._id });
  } catch (error) {
    module.log.error('failed to grant permission', { app: module.app, target, permission, error });
  }
};

module.revokePermission = async (target, permission) => {
  const User = mongoose.model('User');
  try {
    const user = await User.findOne({ email: target }).select('+permissions +flags');
    switch (permission) {
      case 'admin':
        user.flags.isAdmin = false;
        break;
      case 'moderator':
        user.flags.isModerator = false;
        break;
      case 'login':
        user.permissions.canLogin = false;
        break;
      default:
        throw new Error(`Invalid permission: ${permission}`);
    }
    await user.save();
    module.log.info('user updated', { user: user._id });
  } catch (error) {
    module.log.error('failed to revoke permission', { app: module.app, target, permission, error });
  }
};

module.deleteOtpAccount = async (target) => {
  const { otpAuth: otpAuthService } = module.services;
  const User = mongoose.model('User');
  try {
    const user = await User.findOne({ email: target }).lean();
    const response = await otpAuthService.removeForUser(user);
    module.log.info('OTP accounts removed', { userId: user._id, response });
  } catch (error) {
    module.log.error('failed to remove OTP account', { target, error });
  }
};

module.makeBucket = async (target) => {
  const { minio: minioService } = module.services;
  try {
    module.log.info('creating bucket', { target });
    await minioService.makeBucket(target, 'us-east-1');
  } catch (error) {
    module.log.error('failed to create bucket', { target, error });
  }
};

module.resetIndexes = async ( ) => {
  try {
    module.log.info('resetting MongoDB indexes...');
    await SitePlatform.resetIndexes(module);
  } catch (error) {
    module.log.error('failed to reset database indexes', { error });
  }
};

/*
 * SERVER INIT
 */

(async ( ) => {

  const argv = require('argv'); // https://www.npmjs.com/package/argv
  argv.version(module.pkg.version);
  argv.option([
    {
      name: 'action',
      short: 'a',
      type: 'string',
      description: 'The action to perform',
      example: 'sites-cli --action=grant --permission=moderator email email ...',
    },
    {
      name: 'permission',
      short: 'p',
      type: 'string',
      description: 'The permission(s) being added or removed',
      example: 'sites-cli --action=grant --permission=admin email email ...'
    },
  ]);

  try {
    await SitePlatform.startPlatform(module);
  } catch (error) {
    module.log.error('failed to start DTP Sites platform', { error });
    return;
  }
  
  try {
    module.app = argv.run();

    await SiteAsync.each(module.app.targets, async (target) => {
      module.log.info('processing target', { target });
      switch (module.app.options.action) {
        case 'grant':
          await module.grantPermission(target, module.app.options.permission);
          break;

        case 'revoke':
          await module.revokePermission(target, module.app.options.permission);
          break;

        case 'make-bucket':
          await module.makeBucket(target);
          break;

        case 'delete-otp':
          await module.deleteOtpAccount(target);
          break;

        case 'reset-indexes':
          await module.resetIndexes();
          break;

        default:
          throw new Error(`invalid action: ${module.app.options.action}`);
      }
    });
    process.exit(0);
  } catch (error) {
    module.log.error('failed to process target', { app: module.app, error });
  }

})();