'use strict';

var collections = require('../helpers/backend').collections;
var simpleApi = require('./simple-api/simple-api');
var crypto = require('crypto');
var vo = require('vo');
var q = require('q');

const utils = require('../helpers/utils');
var getOptions = require('../helpers/backend').getOptions;
const errorResponse = require('../helpers/response-handler').responseBadRequest;

const generateCorrelationId = require('uuid/v1');
const _ = require('lodash');

const ERROR_CODE_ACCEPT_EULA_REQUIRED = 1036;
const ERROR_CODE_DUPLICATE_EMAIL_ADDRESS = 1000;
const ERROR_CODE_SIMPLE_API_ERROR = 1097;
const ERROR_CODE_REGISTRATION_NOT_CONFIRMED = 1024;

var loggedInSimpleUsers = {};
var LOGGER = require('../../config/logger').logger;

module.exports = {
  register: register,
  validateUserCredentials: validateUserCredentials,
  getSimpleToken: getSimpleToken,
  saveUserObject: saveUserObject //for testing
};

function validateUserCredentials(req, serverRes) {

  LOGGER.info('XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX');
  LOGGER.info('validateUserCredentials START');
  LOGGER.info('XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX');

  var credentials = req.swagger.params.credentials.value;
  var correlationId = req.headers['x-correlation-id'] ? req.headers['x-correlation-id'] : generateCorrelationId();
  let provider = credentials.provider;
  vo(function* () {
    try {
      let loginResult;
      if (provider === 'simple') {
        loginResult = yield performSimpleLogin(credentials, correlationId);
      } else {
        loginResult = yield performSocialLogin(credentials, correlationId);
      }

      serverRes.header('content-type', 'application/json');
      return serverRes.send(loginResult.code, loginResult.body);

    } catch (err) {
      LOGGER.error('Error: ', err);
      return errorResponse(serverRes, err);
    }
  })();
}

function* performSimpleLogin(credentials, correlationId) {

  LOGGER.info('XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX');
  LOGGER.info('performSimpleLogin START', credentials);
  LOGGER.info('XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX');

  let email = credentials.email;
  let password = credentials.password;
  let acceptChecks = credentials.acceptChecks;
  if (acceptChecks && acceptChecks.length === 0) {
    acceptChecks = null;
  }
  if (!email || !password) {
    return {
      code: 403,
      body: {
        message: "TXT_INVALID_CREDENTIALS_ERROR"
      }
    };
  }
  var simpleLoginResult = yield authenticateSimpleUser(email, password, acceptChecks, correlationId);

  LOGGER.info('XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX');
  LOGGER.info('simpleLoginResult', simpleLoginResult);
  LOGGER.info('simple token', getSimpleToken());
  LOGGER.info('XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX');

  if (simpleLoginResult.success) {
    return {
      code: 200,
      body: {
        _id: simpleLoginResult.localUserId
      }
    };
  } else if (simpleLoginResult.message && simpleLoginResult.message.includes(ERROR_CODE_SIMPLE_API_ERROR)) {
    return {
      code: 400,
      body: {
        message: 'TXT_ERROR_CODE_SIMPLE_API_ERROR'
      }
    };
  } else if (simpleLoginResult.message && simpleLoginResult.message.includes(ERROR_CODE_REGISTRATION_NOT_CONFIRMED)) {
    return {
      code: 400,
      body: {
        message: 'TXT_ERROR_CODE_REGISTRATION_NOT_CONFIRMED'
      }
    };
  } else if (simpleLoginResult.gdprNeeded) {
    return {
      code: 400,
      body: {
        message: 'TXT_ERROR_ACCEPT_EULA_REQUIRED'
      }
    };
  } else { //TODO remove local user after full migration to simple
    var localLoginResult = yield authenticateLocalUser(email, password, correlationId);
    if (localLoginResult.success) {
      return {
        code: localLoginResult.code,
        body: {
          _id: localLoginResult._id
        }
      };
    } else {
      return {
        code: localLoginResult.code,
        body: {
          message: localLoginResult.message
        }
      };
    }
  }
}

function* performSocialLogin(credentials, correlationId) {
  let email = credentials.email;
  let provider = credentials.provider;
  let socialToken = credentials.authToken;
  let acceptChecks = credentials.acceptChecks;
  if (acceptChecks && acceptChecks.length === 0) {
    acceptChecks = null;
  }
  LOGGER.info('Credentials: ' + JSON.stringify(credentials));
  let registerResult = yield simpleApi.socialRegister(email, socialToken, provider, acceptChecks, correlationId);
  LOGGER.info('Got register result: ' + JSON.stringify(registerResult));
  if (registerResult.errorCodes && registerResult.errorCodes.includes(ERROR_CODE_ACCEPT_EULA_REQUIRED)) {
    return {
      code: 400,
      body: {
        message: 'TXT_ERROR_SOCIAL_ACCEPT_EULA_REQUIRED'
      }
    };
  } else if (registerResult.errorCodes && !registerResult.errorCodes.includes(ERROR_CODE_DUPLICATE_EMAIL_ADDRESS)) {
    LOGGER.error(`Error while registering social user ${email}, error code is ${JSON.stringify(registerResult.errorCodes)}`);
    return {
      code: 400,
      body: {
        message: 'TXT_ERROR_SOCIAL_REGISTER_FAILED'
      }
    };
    //error
  } else {
    let loginResult = yield simpleApi.socialLogin(email, socialToken, provider, acceptChecks, correlationId);
    LOGGER.info('social: ' + JSON.stringify(loginResult));
    if (loginResult.success) {
      const localUserId = yield ensureLocalUser(email, loginResult.userdata, correlationId);
      saveSimpleTokenForUser(localUserId, loginResult.token, correlationId);

      return {
        code: 200,
        body: {
          _id: localUserId
        }
      };
    } else {
      return {
        code: 400,
        message: JSON.stringify(loginResult.errorCodes)
      };
    }
  }
}

function* authenticateSimpleUser(username, password, acceptChecks, correlationId) {
  var userData = yield simpleApi.login(username, password, acceptChecks, correlationId);
  if (!userData.success) {
    if (userData.errorCodes && userData.errorCodes.includes(ERROR_CODE_ACCEPT_EULA_REQUIRED)) {
      return {
        success: false,
        gdprNeeded: true,
        message: 'TXT_ERROR_ACCEPT_EULA_REQUIRED'
      };
    } else {
      return {
        success: false,
        message: JSON.stringify(userData.errorCodes)
      };
    }
  } else {
    let localUserId = yield ensureLocalUser(username, userData.userdata, correlationId);
    saveSimpleTokenForUser(localUserId, userData.token, correlationId);

    return {
      success: true,
      localUserId: localUserId
    };
  }
}

function* ensureLocalUser(username, userData, correlationId) {
  let localUserId;
  const simpleUserId = userData.userId.toString();
  let localUser = yield getLocalUserByUsername(username, correlationId);
  if (!localUser) {
    let newUser = {
      username: username,
      name: userData.commonName,
      email: userData.email,
      simpleId: simpleUserId,
      password: ''
    };
    localUserId = yield saveUserObject(newUser);
  } else {
    if (!localUser.simpleId) {
      yield saveSimpleIdForUser(localUser._id, simpleUserId, correlationId);
    }

    localUserId = localUser._id;
  }
  return localUserId;
}

function getLocalUserByUsername(username, correlationId) {
  var deferred = q.defer();
  var query = {
    username: username
  };
  var qs = "?query=" + JSON.stringify(query);
  const path = '/api/v1/User/' + qs;
  const option = getOptions(path, correlationId);
  collections.users.get(option, function (err, req, res, users) {
    if (err) {
      LOGGER.error('err: ' + err);
      return deferred.reject(err);
    }
    if (users.length == 0) return deferred.resolve(null);
    var user = users[0];
    deferred.resolve(user);
  });
  return deferred.promise;
}

function getSimpleToken(userId) {
  const user = utils.getUserPropertiesById(userId);
  LOGGER.info(JSON.stringify(user));

  return loggedInSimpleUsers[userId];
}

function* authenticateLocalUser(username, password, correlationId) {
  var user = yield getLocalUserByUsername(username, correlationId);
  if (!user) return {
    code: 403,
    success: false,
    message: "TXT_INVALID_CREDENTIALS_ERROR"
  };
  if (user.password !== hashPassword(password, user.salt)) return {
    code: 403,
    success: false,
    message: "TXT_INVALID_CREDENTIALS_ERROR"
  };
  return {
    code: 200,
    success: true,
    _id: user._id
  };
}

function register(req, serverRes) {
  serverRes.header('content-type', 'application/json');
  var newUser = req.swagger.params.user.value;
  const correlationId = _.get(req.headers, 'x-correlation-id');
  vo(function* () {
    try {
      let registerResult = yield simpleApi.register(newUser.email, newUser.password, newUser.acceptChecks, correlationId);
      if (registerResult.success) {
        var userId = yield saveUserObject(newUser);
        return serverRes.send(200, {
          _id: userId
        });
      } else if (registerResult.errorCodes && registerResult.errorCodes.includes(ERROR_CODE_DUPLICATE_EMAIL_ADDRESS)) {
        LOGGER.error('Failed register result: ' + JSON.stringify(registerResult));
        return errorResponse(serverRes, 'TXT_DUPLICATE_EMAIL_ADDRESS');
      }else if (registerResult.errorCodes && registerResult.errorCodes.includes(ERROR_CODE_SIMPLE_API_ERROR)) {
        LOGGER.error('Failed register result: ' + JSON.stringify(registerResult));
        return errorResponse(serverRes, 'TXT_ERROR_CODE_SIMPLE_API_ERROR');
      } else {
        LOGGER.error('Failed register result: ' + JSON.stringify(registerResult));
        return errorResponse(serverRes, 'TXT_ERROR_REGISTER_FAILED');
      }
    } catch (err) {
      LOGGER.error('err: ' + err);
      return errorResponse(serverRes, 'TXT_ERROR_REGISTER_FAILED');
    }
  })();
}

function saveUserObject(newUser) {
  var deferred = q.defer();
  newUser.salt = generateSalt();
  newUser.password = hashPassword(newUser.password, newUser.salt);
  if (newUser.username) {
    newUser.username.toLowerCase().trim();
  }
  if (newUser.email) {
    newUser.email = newUser.email.toLowerCase().trim();
  }
  //TODO get auth token/user id from headers
  collections.users.post('/api/v1/User/', newUser, function (err, req, res, body) {
    if (err) {
      LOGGER.error('err: ' + err);
      return deferred.reject(err);
    }
    return deferred.resolve(body._id);
  });
  return deferred.promise;
}

function saveSimpleIdForUser(localUserId, simpleUserId, correlationId) {
  const deferred = q.defer();
  const path = `/api/v1/User/${localUserId}`;
  const options = getOptions(path, correlationId);
  const body = { simpleId: simpleUserId };

  collections.users.put(options, body, (err, req, res, user) => {
    if (err) {
      LOGGER.error(`Error while updating user with Simple user id. Local user id: ${localUserId}, Simple user id: ${simpleUserId}. Error: ${err}.`);

      return deferred.reject(err);
    }

    return deferred.resolve(user);
  });

  return deferred.promise;
}

function saveSimpleTokenForUser(localUserId, simpleToken, correlationId) {
  const deferred = q.defer();
  const path = `/api/v1/User/${localUserId}`;
  const options = getOptions(path, correlationId);
  const body = { simpleId: simpleToken };

  collections.users.put(options, body, (err, req, res, user) => {
    if (err) {
      LOGGER.error(`Error while updating user with Simple user token. Local user token: ${localUserId}, Simple user id: ${simpleToken}. Error: ${err}.`);

      return deferred.reject(err);
    }

    return deferred.resolve(user);
  });

  return deferred.promise;
}

function generateSalt() {
  return crypto.randomBytes(16).toString('base64');
}

function hashPassword(password, salt) {
  return crypto.pbkdf2Sync(new Buffer(password, 'base64'), new Buffer(salt, 'base64'), 10000, 64, 'sha1').toString('base64');
}