const models = require('vn-loopback/server/server').models;
const LoopBackContext = require('loopback-context');

describe('Ticket cloning - clone function', () => {
    let ctx;
    let options;
    let tx;

    beforeEach(async() => {
        ctx = {
            req: {
                accessToken: {userId: 9},
                headers: {origin: 'http://localhost'}
            },
            args: {}
        };

        spyOn(LoopBackContext, 'getCurrentContext').and.returnValue({
            active: ctx.req
        });

        options = {transaction: tx};
        tx = await models.Sale.beginTransaction({});
        options.transaction = tx;
    });

    afterEach(async() => {
        await tx.commit();
    });

    it('should create new tickets with cloned sales with warehouse', async() => {
        const salesIds = [1, 2, 3];
        const servicesIds = [];
        const withWarehouse = true;
        const group = false;
        const negative = false;
        const newTickets = await models.Sale.clone(ctx, salesIds, servicesIds, withWarehouse, group, negative, options);

        expect(newTickets).toBeDefined();
        expect(newTickets.length).toBeGreaterThan(0);
    });

    it('should handle negative quantities correctly', async() => {
        const negative = true;
        const salesIds = [7, 8];
        const newTickets = await models.Sale.clone(ctx, salesIds, [], false, false, negative, options);

        // Verify that the cloned sales have negative quantities
        for (const ticket of newTickets) {
            const sales = await models.Sale.find({where: {ticketFk: ticket.id}}, options);
            sales.forEach(sale => {
                expect(sale.quantity).toBeLessThan(0);
            });
        }
    });

    it('should group sales into a single ticket if group is true', async() => {
        const salesIds = [1, 2, 3, 4, 5];
        const group = true;
        const newTickets = await models.Sale.clone(ctx, salesIds, [], false, group, false, options);

        expect(newTickets.length).toEqual(1);
        // Additional assertions for ticket grouping
    });

    it('should create new components and services for cloned tickets', async() => {
        const servicesIds = [2];
        const salesIds = [5];
        const newTickets = await models.Sale.clone(ctx, salesIds, servicesIds, false, false, false, options);

        // Verify that components and services are created for each new ticket
        for (const ticket of newTickets) {
            const sale = await models.Sale.findOne({where: {ticketFk: ticket.id}}, options);
            const components = await models.SaleComponent.find({where: {saleFk: sale.id}}, options);
            const services = await models.TicketService.find({where: {ticketFk: ticket.id}}, options);

            expect(components.length).toBeGreaterThan(0);
            expect(services.length).toBeGreaterThan(0);
        }
    });

    it('should handle transaction rollback on error', async() => {
        const negative = true;
        const salesIds = [1, 2, 3, 4, 5];
        try {
            await models.Sale.clone(ctx, salesIds, [], false, false, negative, options);
            fail('Expected error was not thrown');
        } catch (error) {
            expect(error).toBeDefined();
        }
    });
});