'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);
              });
            });
          }
        });
      }
      */
};