module.exports = Self => {
    Self.remoteMethodCtx('importToNewRefundTicket', {
        description: 'Imports lines from claimBeginning to a new ticket with specific shipped, landed dates, agency and company',
        accessType: 'WRITE',
        accepts: [{
            arg: 'id',
            type: 'number',
            required: true,
            description: 'the claim id',
            http: {source: 'path'}
        }],
        returns: {
            type: 'string',
            root: true
        },
        http: {
            path: `/:id/importToNewRefundTicket`,
            verb: 'POST'
        }
    });

    async function addSalesToTicket(salesToRefund, ticketFk, transaction) {
        let formatedSales = [];
        salesToRefund.forEach(sale => {
            let formatedSale = {
                itemFk: sale.sale().itemFk,
                ticketFk: ticketFk,
                concept: sale.sale().concept,
                quantity: -Math.abs(sale.quantity),
                price: sale.sale().price,
                discount: sale.sale().discount,
                reserved: sale.sale().reserved,
                isPicked: sale.sale().isPicked,
                created: sale.sale().created
            };
            formatedSales.push(formatedSale);
        });
        return await Self.app.models.Sale.create(formatedSales, transaction);
    }

    async function insertIntoClaimEnd(createdSales, claimId, workerId, transaction) {
        let formatedSales = [];
        createdSales.forEach(sale => {
            let formatedSale = {
                saleFk: sale.id,
                claimFk: claimId,
                workerFk: workerId
            };
            formatedSales.push(formatedSale);
        });
        return await Self.app.models.ClaimEnd.create(formatedSales, transaction);
    }

    async function saveObservation(observation, transaction) {
        let query = `INSERT INTO vn.ticketObservation(ticketFk, observationTypeFk, description) VALUES(?, ?, ?)
        ON DUPLICATE KEY UPDATE description = CONCAT(vn.ticketObservation.description, VALUES(description),' ')`;
        await Self.rawSql(query, [
            observation.ticketFk,
            observation.observationTypeFk,
            observation.description
        ], transaction);
    }

    Self.importToNewRefundTicket = async (ctx, id) => {
        let models = Self.app.models;
        let token = ctx.req.accessToken;
        let userId = token.userId;
        let worker = await models.Worker.findOne({where: {userFk: userId}});
        let obsevationType = await models.ObservationType.findOne({where: {description: 'comercial'}});
        let agency = await models.AgencyMode.findOne({where: {code: 'refund'}});
        let state = await models.State.findOne({where: {code: 'DELIVERED'}});

        let filter = {
            where: {id: id},
            include: [
                {
                    relation: 'ticket',
                    scope: {
                        fields: ['id', 'clientFk', 'warehouseFk', 'companyFk', 'addressFk']
                    }
                }
            ]
        };

        let claim = await models.Claim.findOne(filter);

        let today = new Date();

        let params = {
            clientFk: claim.ticket().clientFk,
            shipped: today,
            landed: today,
            warehouseFk: claim.ticket().warehouseFk,
            companyFk: claim.ticket().companyFk,
            addressFk: claim.ticket().addressFk,
            agencyModeFk: agency.id,
            userId: userId
        };

        let salesFilter = {
            where: {claimFk: id},
            include: [
                {
                    relation: 'sale',
                    scope: {
                        fields: ['id', 'itemFk', 'concept', 'price', 'discount', 'reserved', 'isPicked', 'created', 'priceFixed', 'isPriceFixed']
                    }
                }
            ]
        };

        let transaction = await Self.beginTransaction({});

        try {
            let newRefundTicket = await models.Ticket.new(ctx, params, {transaction: transaction});

            let observation = {
                description: `Reclama ticket: ${claim.ticketFk}`,
                ticketFk: newRefundTicket.id,
                observationTypeFk: obsevationType.id
            };
            await saveObservation(observation, {transaction: transaction});

            await models.TicketTracking.create({
                ticketFk: newRefundTicket.id,
                stateFk: state.id,
                workerFk: worker.id
            }, {transaction: transaction});

            let salesToRefund = await models.ClaimBeginning.find(salesFilter);
            let createdSales = await addSalesToTicket(salesToRefund, newRefundTicket.id, {transaction: transaction});
            insertIntoClaimEnd(createdSales, id, worker.id, {transaction: transaction});

            await Self.rawSql('CALL vn.ticketCalculateClon(?, ?)', [
                newRefundTicket.id, claim.ticketFk
            ], {transaction: transaction});

            let claimState = await Self.app.models.ClaimState.findOne({where: {description: 'Resuelto'}});

            await claim.updateAttribute('claimStateFk', claimState.id, {transaction: transaction});

            await transaction.commit();

            return newRefundTicket;
        } catch (e) {
            await transaction.rollback();
            throw e;
        }
    };
};