'use strict';

const Boom = require('boom');
const conn = require('../dal/pgConnection');
const config = require('config');
const accountDal = require('../dal/accounts');
const userDal = require('../dal/users');
const householdDal = require('../dal/households');
const deviceDal = require('../dal/devices');
const shineCoinsDal = require('../dal/shineCoins');
// const productsDal = require('../dal/products');
const disposableEmail = require('../helpers/disposableEmailHelper');
const KCAdminClient = require('../services/keyCloakAdminClientService');
const Hubspot = require('../services/hubspotService.js');
module.exports = {
  /**
     * Add account action
     * @param params The request params
     * @param res The response object
     * @param next Function that can be called in case of an error
     */
  createAccount: function (params, res, next) {
    let client,
      done;
    let kcAdminClient = KCAdminClient.getInstance();
    let account = params.account.value;
    let userId,
      accountId;
    let email = account.email.trim().toLowerCase();
    return new Promise(function (resolve, reject) {
      conn.execute().then((connection) => {
        client = connection.client;
        done = connection.done;
        return disposableEmail.checkAddress(config.disposableEmailUrl, email);
      }).then(() => {
        return accountDal.createAccount(client);
      }).then((newAccountId) => {
        accountId = newAccountId;
        return userDal.createUser(client, accountId, account, true);
      }).then((newUserId) => {
        userId = newUserId;
        return userDal.createUserPreferences(client, userId, account);
      }).then(() => {
        return kcAdminClient.createUser({
          email: email,
          username: email,
          firstName: account.firstName,
          lastName: account.lastName,
          accountId: accountId,
          userId: userId,
          password: account.password
        });
      }).then(() => {
        return conn.commit(client, done).then(() => {
          resolve({
            accountId: accountId,
            userId: userId
          });
          return Hubspot.create({
            email: email,
            green: account.green,
            flex: account.flex,
            bonus: account.bonus
          }).then(() => {
            return true;
          }).catch((err) => {
            if (err.statusCode === 409) {
              return Hubspot.update(email, {
                green: account.green,
                flex: account.flex,
                bonus: account.bonus
              });
            }
          });
        });
      }).catch((err) => {
        return conn.rollback(client, done).then(() => {
          if (Boom.isBoom(err)) {
            return reject(err);
          } else {
            return reject(Boom.badImplementation());
          }
        });
      });
    });
  },

  /**
     * Get everything related to a Account
     * @param params The request params
     * @param res The response object
     * @param next Function that can be called in case of an error
     */
  readAccount: function (params, res, next) {
    let client, done;
    let accountId = params.accountId.value;
    let householdResponseDev;
    let users = [];
    let households = [];
    let devices = [];
    let redoutDevices = {};
    let balance;
    let idHousehold = 0;

    return new Promise(function (resolve, reject) {
      conn.execute().then((connection) => {
        client = connection.client;
        done = connection.done;

        const userPromise = userDal.readUsers(client, accountId)
          .then((userResponse) => {
            userResponse.forEach((valueUser) => {
              const redoutUser = {
                userId: valueUser.id,
                accountId: accountId,
                email: valueUser.email,
                green: valueUser.green,
                flex: valueUser.flex,
                bonus: valueUser.bonus,
                firstName: valueUser.first_name,
                lastName: valueUser.last_name,
                accountAdmin: valueUser.account_admin
              };
              users.push(redoutUser);
            });
          });

        const householdPromise = householdDal.readHouseholds(client, accountId)
          .then((householdResponse) => {
            householdResponseDev = householdResponse;

            householdResponse.forEach((value) => {
              idHousehold = value.id;
              return idHousehold;
            });
            return idHousehold;
          });

        const coinsPromise = shineCoinsDal.readCoinBalance(client, accountId)
          .then((amountShineCoins) => {
            balance = amountShineCoins.amount;
          });

        Promise.all([userPromise, householdPromise, coinsPromise]).then((readPromises) => {
          let devicePromise = [];
          if (readPromises[1]) {
            devicePromise.push(deviceDal.readDevicesForHousehold(client, idHousehold)
              .then((deviceResult) => {
                deviceResult.forEach((deviceTypeValue) => {
                  redoutDevices = {
                    deviceAlias: deviceTypeValue.device_alias,
                    deviceType: deviceTypeValue.device_type,
                    manufacturer: deviceTypeValue.manufacturer,
                    model: deviceTypeValue.model
                  };
                  devices.push(redoutDevices);
                })
                householdResponseDev.forEach((valueHousehold) => {
                  const redoutHouseholds = {
                    address: valueHousehold.address,
                    zipcode: valueHousehold.zipcode,
                    city: valueHousehold.city,
                    country: valueHousehold.country,
                    latitude: valueHousehold.latitude,
                    longitude: valueHousehold.longitude,
                    consumptionInKwh: valueHousehold.consumption_in_kwh,
                    peopleInHousehold: valueHousehold.people_in_household,
                    propertyOwnership: valueHousehold.property_ownership,
                    buildingType: valueHousehold.building_type,
                    supplierName: valueHousehold.supplier,
                    tariffName: valueHousehold.tariff,
                    electricityImport: valueHousehold.electricity_import,
                    electricityExport: valueHousehold.electricity_export,
                    gasImport: valueHousehold.gas_import,
                    devices: devices
                  }
                  households.push(redoutHouseholds);
                });
              })
            );
          }
        })

          .then(() => {
            return conn.commit(client, done).then(() => {
              return res.sendJSON({
                users: users,
                households: households,
                balance: balance
              });
            });
          }).catch((err) => {
            return conn.rollback(client, done).then(() => {
              if (Boom.isBoom(err)) {
                return reject(err);
              } else {
                return reject(Boom.badImplementation());
              }
            });
          });
      });
    });
  }

  /*
      updateAdminRights: function (params, res, next) {
        conn.execute(function (err, client, done) {
          if (err) {
            res.sendJSON(err, 500);
          }
          let users = params.rights.value.users;
          for (let i = 0; i < users.length; i++) {
            userDal.updateUser(client, {
              admin: users[i].is_account_admin,
              id: users[i].user_id
            }, function (err, success) {
              if (err) {
                return conn.rollback(client, done, function () {
                  Boom.boomify(err, {statusCode: 500});
                });
              }
              conn.commit(client, done, function (err) {
                if (err) {
                  return Boom.boomify(err, {statusCode: 500});
                }
                return res.sendJSON('Admin rights updated', 204);
              });
            });
          }
        });
      }
      */
}