'use strict';


const internals = module.exports = {};
const Boom = require('boom');
const debug = require('debug')('hapi-leasing-models:lease-agreement:methods');



internals.leaseExists = function (id, callback){
    const leaseAgreement = this.LeaseAgreement;

    return leaseAgreement.findById(id)
        .then((leaseAgreement) => {
            debug('in then handler of promise', id);
            if (!leaseAgreement) {
                debug('DID NOT FIND LEASE');
                return false;
            }
            return true;
        })
        .catch(err => {
            debug('error caaght %s', id);
            return Promise.reject(Boom.wrap(err));
        })
        .nodeify(callback);
};


internals.generateId = function (callback){
    debug('generating a lease-id...');

    const model = this.LeaseAgreement;

    const generateUniqueId = () => {
        const id = `${Math.floor(Math.random() * 900000000000) + 100000000000}`;

        return model.findById(id)
            .then(found => {
                // If not found then resolve with the id b/c its unique and not in db
                if (!found){
                    return Promise.resolve({ id });
                }

                // If something found, then error out
                return Promise.reject(new Error('Id is not unique'));
            });
    };


    const proms = [];
    for (let i = 0; i < 5; i++){
        proms.push(generateUniqueId(model));
    }

    return Promise.any(proms)
        .then((resp) => {
            debug('generated Id: %O', resp);
            return resp;
        })
        .catch(() => Promise.reject(new Error('Unique id cannot be generated in 5 tries')))
        .nodeify(callback);
};

internals.updateLease = function (leaseId, updateData, callback){
    return this.LeaseAgreement.findByIdAndUpdate(leaseId, { $set: updateData })
        .then(resp => {
            if (!resp){
                const error = Boom.notFound(`Provided leaseId ${leaseId} was not found`);
                return Promise.reject(error);
            }
            return { msg: 'Lease Updated' };
        })
        .catch(err => {
            const error = Boom.wrap(err);
            return Promise.reject(error);
        })
        .nodeify(callback);
};

internals.deleteLease = function (id, callback){
    return this.LeaseAgreement.findByIdAndUpdate(id, {
        $set: {
            deletedAt: new Date(),
            updatedAt: new Date()
        }
    })
    .then((leaseAgreement) => {
        if (!leaseAgreement) {
            debug('DID NOT FIND LEASE');
            return Promise.reject(Boom.notFound(`Provided leaseId (${id}) was not found in db`));
        }

        debug('leaseId %s for %s was deleted', leaseAgreement._id, leaseAgreement.customerId);
        return !!leaseAgreement;
    })
    .catch(err => {
        const error = Boom.wrap(err);
        return Promise.reject(error);
    })
    .nodeify(callback);
};

internals.findLeaseById = function (id, callback){
    return this.LeaseAgreement.findById(id)
        .then((leaseAgreement) => {
            if (!leaseAgreement) {
                debug('DID NOT FIND LEASE');
                return Promise.reject(Boom.notFound(`Provided leaseId (${id}) was not found in db`));
            }

            debug('Found lease for customerId %s', leaseAgreement.customerId);
            return leaseAgreement;
        })
        .catch(err => {
            const error = Boom.wrap(err);
            return Promise.reject(error);
        })
        .nodeify(callback);
};

internals.isLeaseSignable = function (leaseAgreement, reply){
    const now = new Date();

    if (leaseAgreement.expiresAt < now) {
        debug('This lease is EXPIRED!!! %s', leaseAgreement._id);
        return reply(Boom.resourceGone('The lease expired. Please create a new lease.'));
    }

    if (leaseAgreement.signed === true) {
        debug('This lease is already signed %s', leaseAgreement._id);
        return reply(Boom.resourceGone('The lease was already signed. Please create a new lease.'));
    }

    return reply(null, true);
};

internals.findLeases = function (query, callback){

    debug('[server-method: findLease]: executing..');

    const leaseAgreement = this.LeaseAgreement;

    let {
        sort = 'createdAt',
        limit = 20,
        page = 1,
        filter = {},
        fields = {}
    } = query;

    if (_.isString(filter)){
        try {
            filter = JSON.parse(filter, (key, value) => {
                const d = moment(value,  [moment.ISO_8601], false);
                return (d.isValid()) ? moment(value).toDate() : value;
            });
        } catch (err){
            filter = {};
        }
    }

    if (_.isString(fields)){
        try {
            fields = JSON.parse(fields);
        } catch (err){
            fields = {};
        }
    }

    debug('sort: %o', sort);
    debug('limit: %o', limit);
    debug('page: %o', page);
    debug('filter: %o', filter);
    debug('fields: %o', fields);

    return leaseAgreement.pagedFind(filter, fields, sort, limit, page)
        .then(resp => {
            debug('[server-method: findLease]: resp = %O', resp);
            return resp;
        })
        .catch((err) => {
            debug('There was an error getting leases %O', err);
            return Promise.reject(Boom.wrap(err));
        })
        .nodeify(callback);

};

internals.updateLease = function (leaseId, updateData, callback){
    return this.LeaseAgreement.findByIdAndUpdate(leaseId, { $set: updateData })
        .then(resp => {
            if (!resp){
                const error = Boom.notFound(`Provided leaseId ${leaseId} was not found`);
                return Promise.reject(error);
            }
            return { msg: 'Lease Updated' };
        })
        .catch(err => {
            const error = Boom.wrap(err);
            return Promise.reject(error);
        })
        .nodeify(callback);
};