var request = require('request-promise');
var fs = require('fs');
var common = require('../../routes/common');
var logger = require('../shared/logger');
var options = {};

function getFilesList(callback) {
  let files_list = [];
  let all_restore_exists = false;
  let response = {all_restore_exists: false, files: []};
  fs.readdir(common.selectedNode.channel_backup_path + common.path_separator + 'restore', function (err, files) {
    if (err && err.code !== 'ENOENT' && err.errno !== -4058) { 
      response = { message: 'Channels Restore List Failed!', error: err, statusCode: 500 };
    }
    if (files && files.length > 0) {
      files.forEach(file => {
        if (!file.includes('.restored')) {
          if (file.toLowerCase() === 'channel-all.bak' || file.toLowerCase() === 'backup-channel-all.bak') {
            all_restore_exists = true;
          } else {
            files_list.push({channel_point: file.substring(8, file.length - 4).replace('-', ':')});
          }
        }
      });
    }
    response = {all_restore_exists: all_restore_exists, files: files_list};
    callback(response);
  });
}

exports.getBackup = (req, res, next) => {
  logger.log({level: 'INFO', fileName: 'ChannelBackup', msg: 'Getting Channel Backup..'});
  options = common.getOptions();
  let channel_backup_file = '';
  let message = '';
  if (req.params.channelPoint === 'ALL') {
    channel_backup_file = common.selectedNode.channel_backup_path + common.path_separator + 'channel-all.bak';
    message = 'All Channels Backup Successful.';
    options.url = common.getSelLNServerUrl() + '/v1/channels/backup';
  } else {
    channel_backup_file = common.selectedNode.channel_backup_path + common.path_separator + 'channel-' + req.params.channelPoint.replace(':', '-') + '.bak';
    message = 'Channel Backup Successful.';
    let channelpoint = req.params.channelPoint.replace(':', '/');
    options.url = common.getSelLNServerUrl() + '/v1/channels/backup/' + channelpoint;
    let exists = fs.existsSync(channel_backup_file);
    if (exists) {
      fs.writeFile(channel_backup_file, '', () => { });
    } else {
      try {
        var createStream = fs.createWriteStream(channel_backup_file);
        createStream.end();
      }
      catch (errRes) {
        const err = common.handleError(errRes,  'ChannelsBackup', 'Backup Channels Error');
        return res.status(err.statusCode).json({message: err.message, error: err.error});
      }
    }
  }
  request(options).then(function (body) {
    logger.log({level: 'DEBUG', fileName: 'ChannelsBackup', msg: 'Channel Backup', data: body});
    fs.writeFile(channel_backup_file, JSON.stringify(body), function(errRes) {
      if (errRes) {
        const err = common.handleError(errRes,  'ChannelsBackup', 'Backup Channels Error');
        return res.status(err.statusCode).json({message: err.message, error: err.error});
      } else {
        logger.log({level: 'INFO', fileName: 'ChannelBackup', msg: 'Channel Backup Finished'});
        res.status(200).json({ message: message });
      }
    });
  })
  .catch(errRes => {
    const err = common.handleError(errRes,  'ChannelsBackup', 'Backup Channels Error');
    return res.status(err.statusCode).json({message: err.message, error: err.error});
  });
};

exports.postBackupVerify = (req, res, next) => {
  logger.log({level: 'INFO', fileName: 'ChannelBackup', msg: 'Verifying Channel Backup..'});
  options = common.getOptions();
  options.url = common.getSelLNServerUrl() + '/v1/channels/backup/verify';
  let channel_verify_file = '';
  let message = '';
  let verify_backup = '';
  if (req.params.channelPoint === 'ALL') {
    message = 'All Channels Verify Successful.';
    channel_verify_file = common.selectedNode.channel_backup_path + common.path_separator + 'channel-all.bak';
    let exists = fs.existsSync(channel_verify_file);
    if (exists) {
      verify_backup = fs.readFileSync(channel_verify_file, 'utf-8');
      if (verify_backup !== '') {
        verify_backup = JSON.parse(verify_backup);
        delete verify_backup.single_chan_backups;
        options.form = JSON.stringify(verify_backup);
      } else {
        const errMsg = 'Channel backup to verify does not Exist.';
        const err = common.handleError({ statusCode: 404, message: 'Verify Channel Error', error: errMsg },  'ChannelBackup', errMsg);
        return res.status(err.statusCode).json({message: err.message, error: err.error});
      }
    } else {
      verify_backup = '';
      const errMsg = 'Channel backup to verify does not Exist.';
      const err = common.handleError({ statusCode: 404, message: 'Verify Channel Error', error: errMsg },  'ChannelBackup', errMsg);
      return res.status(err.statusCode).json({message: err.message, error: err.error});
    }
  } else {
    message = 'Channel Verify Successful.';
    channel_verify_file = common.selectedNode.channel_backup_path + common.path_separator + 'channel-' + req.params.channelPoint.replace(':', '-') + '.bak';
    let exists = fs.existsSync(channel_verify_file);
    if (exists) {
      verify_backup = fs.readFileSync(channel_verify_file, 'utf-8');
      options.form = JSON.stringify({ single_chan_backups: { chan_backups: [JSON.parse(verify_backup)] } });
    } else {
      verify_backup = '';
      const errMsg = 'Channel backup to verify does not Exist.';
      const err = common.handleError({ statusCode: 404, message: 'Verify Channel Error', error: errMsg },  'ChannelBackup', errMsg);
      return res.status(err.statusCode).json({message: err.message, error: err.error});
    }
  }
  if (verify_backup !== '') {
    request.post(options).then(function (body) {
      logger.log({level: 'DEBUG', fileName: 'ChannelBackup', msg: 'Channel Backup Verify', data: body});
      logger.log({level: 'INFO', fileName: 'ChannelBackup', msg: 'Channel Backup Verified'});
      res.status(201).json({ message: message });
    })
    .catch(errRes => {
      const err = common.handleError(errRes,  'ChannelsBackup', 'Verify Channels Error');
      return res.status(err.statusCode).json({message: err.message, error: err.error});
    });
  }
};

exports.postRestore = (req, res, next) => {
  logger.log({level: 'INFO', fileName: 'ChannelBackup', msg: 'Restoring Channel Backup..'});
  options = common.getOptions();
  options.url = common.getSelLNServerUrl() + '/v1/channels/backup/restore';
  let channel_restore_file = '';
  let message = '';
  let restore_backup = '';
  if (req.params.channelPoint === 'ALL') {
    message = 'All Channels Restore Successful.';
    channel_restore_file = common.selectedNode.channel_backup_path + common.path_separator + 'restore' + common.path_separator;
    let exists = fs.existsSync(channel_restore_file + 'channel-all.bak');
    let downloaded_exists = fs.existsSync(channel_restore_file + 'backup-channel-all.bak');
    if (exists) {
      restore_backup = fs.readFileSync(channel_restore_file + 'channel-all.bak', 'utf-8');
      if (restore_backup !== '') {
        restore_backup = JSON.parse(restore_backup);
        options.form = JSON.stringify({multi_chan_backup: restore_backup.multi_chan_backup.multi_chan_backup});
      } else {
        const errMsg = 'Channel backup to restore does not Exist.';
        const err = common.handleError({ statusCode: 404, message: 'Restore Channel Error', error: errMsg },  'ChannelBackup', errMsg);
        return res.status(err.statusCode).json({message: err.message, error: err.error});
      }
    } else if (downloaded_exists) {
      restore_backup = fs.readFileSync(channel_restore_file + 'backup-channel-all.bak', 'utf-8');
      if (restore_backup !== '') {
        restore_backup = JSON.parse(restore_backup);
        options.form = JSON.stringify({multi_chan_backup: restore_backup.multi_chan_backup.multi_chan_backup});
      } else {
        const errMsg = 'Channel backup to restore does not Exist.';
        const err = common.handleError({ statusCode: 404, message: 'Restore Channel Error', error: errMsg },  'ChannelBackup', errMsg);
        return res.status(err.statusCode).json({message: err.message, error: err.error});
      }
    } else {
      restore_backup = '';
      const errMsg = 'Channel backup to restore does not Exist.';
      const err = common.handleError({ statusCode: 404, message: 'Restore Channel Error', error: errMsg },  'ChannelBackup', errMsg);
      return res.status(err.statusCode).json({message: err.message, error: err.error});
    }
  } else {
    message = 'Channel Restore Successful.';
    channel_restore_file = common.selectedNode.channel_backup_path + common.path_separator + 'restore' + common.path_separator + 'channel-' + req.params.channelPoint.replace(':', '-') + '.bak';
    let exists = fs.existsSync(channel_restore_file);
    if (exists) {
      restore_backup = fs.readFileSync(channel_restore_file, 'utf-8');
      options.form = JSON.stringify({ chan_backups: { chan_backups: [JSON.parse(restore_backup)] } });
    } else {
      restore_backup = '';
      const errMsg = 'Channel backup to restore does not Exist.';
      const err = common.handleError({ statusCode: 404, message: 'Restore Channel Error', error: errMsg },  'ChannelBackup', errMsg);
      return res.status(err.statusCode).json({message: err.message, error: err.error});
    }
  }
  if (restore_backup !== '') {
    request.post(options).then(function (body) {
      logger.log({level: 'DEBUG', fileName: 'ChannelBackup', msg: 'Channel Backup Restore', data: body});
      if(req.params.channelPoint === 'ALL') { channel_restore_file = channel_restore_file + 'channel-all.bak'; }
      fs.rename(channel_restore_file, channel_restore_file + '.restored', () => {
        getFilesList(getFilesListRes => {
          if (getFilesListRes.error) {
            const errMsg = getFilesListRes.error;
            const err = common.handleError({ statusCode: 500, message: 'Restore Channel Error', error: errMsg },  'ChannelBackup', errMsg);
            return res.status(err.statusCode).json({message: err.error, list: getFilesListRes});
          } else {
            logger.log({level: 'INFO', fileName: 'ChannelBackup', msg: 'Channel Restored'});
            return res.status(201).json({ message: message, list: getFilesListRes });
          }
        });      
      });
    })
    .catch(errRes => {
      const err = common.handleError(errRes,  'ChannelsBackup', 'Restore Channel Error');
      return res.status(err.statusCode).json({message: err.message, error: err.error});
    });
  }
};

exports.getRestoreList = (req, res, next) => {
  getFilesList(getFilesListRes => {
    if (getFilesListRes.error) {
      return res.status(getFilesListRes.statusCode).json(getFilesListRes);
    } else {
      return res.status(200).json(getFilesListRes);
    }
  });
};