import {
    getAllLineItems,
    getCartTotal,
    getDeductible,
    getLineItems,
    getMobileFeeLineItem, getNonServiceLineItems,
    getRecycleFeeLineItem, getSalesTax,
    getServiceLineItems, getSubtotal, isOrderITAC, isOrderNoComp,
    isOrderUnverified
} from '@/helpers/cart-helper';
import partTypeStrings from '@/constants/part-type-strings';
import partNumberStrings from '@/constants/part-number-strings';

describe('cart-helper', () => {
    function createDummyItem(partNumber, price, salesTax) {
        return {
            partNumber,
            sellingPrice: price,
            kitPrice: 0,
            laborAmount: 0,
            salesTax
        };
    }

    function createDummyFeeItem(partNumber, partType, price, salesTax) {
        return {
            partNumber,
            partType,
            sellingPrice: price,
            kitPrice: 0,
            laborAmount: 0,
            salesTax
        };
    }

    const nullLineItems = {
        supportingItems: null,
        glassParts: null,
        otherParts: null,
        vaps: null,
        feeItems: null
    };

    const emptyLineItems = {
        supportingItems: [],
        glassParts: [],
        otherParts: [],
        vaps: [],
        feeItems: []
    };

    const supportingLineItem = createDummyItem('supporting', 30, 1);
    const glassLineItem = createDummyItem('glass', 40, 2);
    const otherLineItem = createDummyItem('other', 50, 3);
    const vapsLineItem = createDummyItem('vaps', 60, 4);
    const mobileFeeLineItem = createDummyFeeItem(null, partTypeStrings.MOBILE_FEE, 70, 5);
    const recycleFeeLineItem = createDummyFeeItem(partNumberStrings.RECYCLE_FEE, null, 80, 6);

    const defaultLineItems = {
        supportingItems: [supportingLineItem],
        glassParts: [glassLineItem],
        otherParts: [otherLineItem],
        vaps: [vapsLineItem],
        feeItems: [mobileFeeLineItem, recycleFeeLineItem]
    };

    describe('getLineItems', () => {
        test('Returns line items', () => {
            // Arrange
            const order = {
                lineItems: emptyLineItems
            };

            // Act
            const result = getLineItems(order);

            // Assert
            expect(result).toMatchObject(order.lineItems);
        });
    });

    describe('getServiceLineItems', () => {
        test('Returns only service line items', () => {
            // Arrange
            const order = {
                lineItems: defaultLineItems
            };

            // Act
            const result = getServiceLineItems(order);

            // Assert
            expect(result).toHaveLength(3);
            expect(result).toContain(supportingLineItem);
            expect(result).toContain(glassLineItem);
            expect(result).toContain(otherLineItem);
        });

        test('Returns empty array when line items are null', () => {
            // Arrange
            const order = {
                lineItems: nullLineItems
            };

            // Act
            const result = getServiceLineItems(order);

            // Assert
            expect(result).toHaveLength(0);
        });
    });

    describe('getNonServiceLineItems', () => {
        test('Returns only service line items', () => {
            // Arrange
            const order = {
                lineItems: defaultLineItems
            };

            // Act
            const result = getNonServiceLineItems(order);

            // Assert
            expect(result).toHaveLength(3);
            expect(result).toContain(vapsLineItem);
            expect(result).toContain(mobileFeeLineItem);
            expect(result).toContain(recycleFeeLineItem);
        });

        test('Returns empty array when line items are null', () => {
            // Arrange
            const order = {
                lineItems: nullLineItems
            };

            // Act
            const result = getNonServiceLineItems(order);

            // Assert
            expect(result).toHaveLength(0);
        });
    });

    describe('getAllLineItems', () => {
        test('Returns all line items', () => {
            // Arrange
            const order = {
                lineItems: defaultLineItems
            };

            // Act
            const result = getAllLineItems(order);

            // Assert
            expect(result).toHaveLength(6);
            expect(result).toContain(supportingLineItem);
            expect(result).toContain(glassLineItem);
            expect(result).toContain(otherLineItem);
            expect(result).toContain(vapsLineItem);
            expect(result).toContain(mobileFeeLineItem);
            expect(result).toContain(recycleFeeLineItem);
        });

        test('Returns empty array when line items are null', () => {
            // Arrange
            const order = {
                lineItems: nullLineItems
            };

            // Act
            const result = getAllLineItems(order);

            // Assert
            expect(result).toHaveLength(0);
        });
    });

    describe('getRecycleFee', () => {
        test('Returns recycle fee when present', () => {
            // Arrange
            const order = {
                lineItems: defaultLineItems
            };

            // Act
            const result = getRecycleFeeLineItem(order);

            // Assert
            expect(result).not.toBeNull();
            expect(result).toMatchObject(recycleFeeLineItem);
        });

        test('Returns undefined recycle fee when not present', () => {
            // Arrange
            const order = {
                lineItems: emptyLineItems
            };

            // Act
            const result = getRecycleFeeLineItem(order);

            // Assert
            expect(result).toBeUndefined();
        });
    });

    describe('getMobileFee', () => {
        test('Returns mobile fee when present', () => {
            // Arrange
            const order = {
                lineItems: defaultLineItems
            };

            // Act
            const result = getMobileFeeLineItem(order);

            // Assert
            expect(result).not.toBeNull();
            expect(result).toMatchObject(mobileFeeLineItem);
        });

        test('Returns undefined mobile fee when not present', () => {
            // Arrange
            const order = {
                lineItems: emptyLineItems
            };

            // Act
            const result = getMobileFeeLineItem(order);

            // Assert
            expect(result).toBeUndefined();
        });
    });

    describe('getDeductible', () => {
        test('Returns deductible on the order', () => {
            // Arrange
            const deductible = 100;
            const order = {
                currentDeductible: deductible
            };

            // Act
            const result = getDeductible(order);

            // Assert
            expect(result).not.toBeNull();
            expect(result).toBe(deductible);
        });
    });

    describe('isOrderUnverified', () => {
        test.each([[false, false], [true, true]])('Returns %p when policy.isUnverified is %p', (expected, isUnverified) => {
            // Arrange
            const order = {
                isUnverified
            };

            // Act
            const result = isOrderUnverified(order);

            // Assert
            expect(result).toBe(expected);
        });
    });

    describe('isOrderNoComp', () => {
        test('Returns false when policy is null', () => {
            // Arrange
            const order = {};

            // Act
            const result = isOrderNoComp(order);

            // Assert
            expect(result).toBeFalsy();
        });

        test.each([[false, false], [true, true]])('Returns %p when policy.NoCoverage is %p', (expected, noCoverage) => {
            // Arrange
            const order = {
                policy: {
                    noCoverage
                }
            };

            // Act
            const result = isOrderNoComp(order);

            // Assert
            expect(result).toBe(expected);
        });
    });

    describe('isOrderITAC', () => {
        test('Returns false when policy is null', () => {
            // Arrange
            const order = {};

            // Act
            const result = isOrderITAC(order);

            // Assert
            expect(result).toBeFalsy();
        });

        test.each([[false, false], [true, true]])('Returns %p when policy.isITAC is %p', (expected, isITAC) => {
            // Arrange
            const order = {
                policy: {
                    isITAC
                }
            };

            // Act
            const result = isOrderITAC(order);

            // Assert
            expect(result).toBe(expected);
        });
    });

    describe('getSubtotal', () => {
        test('Returns 0 when there are null items', () => {
            // Arrange
            const order = {
                isUnverified: false,
                policy: {
                    noCoverage: true
                },
                lineItems: nullLineItems
            };

            // Act
            const result = getSubtotal(order);

            // Assert
            expect(result).toBe(0);
        });

        test('Returns 0 when there are no items', () => {
            // Arrange
            const order = {
                isUnverified: false,
                policy: {
                    noCoverage: true
                },
                lineItems: emptyLineItems
            };

            // Act
            const result = getSubtotal(order);

            // Assert
            expect(result).toBe(0);
        });

        test('Returns sub total of deductible + vaps + fee line items when verified deductible', () => {
            // Arrange
            const order = {
                isUnverified: false,
                policy: {
                    noCoverage: false,
                    isITAC: false
                },
                currentDeductible: 100,
                lineItems: defaultLineItems
            };

            // Act
            const result = getSubtotal(order);

            // Assert
            expect(result).toBe(310);
        });

        test('Returns sub total of all line items when verified no comp', () => {
            // Arrange
            const order = {
                isUnverified: false,
                policy: {
                    noCoverage: true,
                    isITAC: false
                },
                currentDeductible: 0,
                lineItems: defaultLineItems
            };

            // Act
            const result = getSubtotal(order);

            // Assert
            expect(result).toBe(330);
        });

        test('Returns sub total of all line items when verified ITAC', () => {
            // Arrange
            const order = {
                isUnverified: false,
                policy: {
                    noCoverage: false,
                    isITAC: true
                },
                currentDeductible: 0,
                lineItems: defaultLineItems
            };

            // Act
            const result = getSubtotal(order);

            // Assert
            expect(result).toBe(330);
        });
    });

    describe('getSalesTax', () => {
        test('Returns 0 when there are null items', () => {
            // Arrange
            const order = {
                isUnverified: false,
                policy: {
                    noCoverage: true
                },
                lineItems: nullLineItems
            };

            // Act
            const result = getSalesTax(order);

            // Assert
            expect(result).toBe(0);
        });

        test('Returns 0 when there are no items', () => {
            // Arrange
            const order = {
                isUnverified: false,
                policy: {
                    noCoverage: true
                },
                lineItems: emptyLineItems
            };

            // Act
            const result = getSalesTax(order);

            // Assert
            expect(result).toBe(0);
        });

        test('Returns sales tax vaps + fee line items when verified', () => {
            // Arrange
            const order = {
                isUnverified: false,
                policy: {
                    noCoverage: false,
                    isITAC: false
                },
                currentDeductible: 100,
                lineItems: defaultLineItems
            };

            // Act
            const result = getSalesTax(order);

            // Assert
            expect(result).toBe(15);
        });

        test('Returns sales tax of all line items when verified no comp', () => {
            // Arrange
            const order = {
                isUnverified: false,
                policy: {
                    noCoverage: true,
                    isITAC: false
                },
                currentDeductible: 0,
                lineItems: defaultLineItems
            };

            // Act
            const result = getSalesTax(order);

            // Assert
            expect(result).toBe(21);
        });

        test('Returns sales tax of all line items when verified ITAC', () => {
            // Arrange
            const order = {
                isUnverified: false,
                policy: {
                    noCoverage: false,
                    isITAC: true
                },
                currentDeductible: 0,
                lineItems: defaultLineItems
            };

            // Act
            const result = getSalesTax(order);

            // Assert
            expect(result).toBe(21);
        });
    });

    describe('getCartTotal', () => {
        test('Returns 0 when there are null items', () => {
            // Arrange
            const order = {
                isUnverified: false,
                policy: {
                    noCoverage: true
                },
                lineItems: nullLineItems
            };

            // Act
            const result = getCartTotal(order);

            // Assert
            expect(result).toBe(0);
        });

        test('Returns 0 when there are no items', () => {
            // Arrange
            const order = {
                isUnverified: false,
                policy: {
                    noCoverage: true
                },
                lineItems: emptyLineItems
            };

            // Act
            const result = getCartTotal(order);

            // Assert
            expect(result).toBe(0);
        });

        test('Returns total of vaps + fee line items when verified', () => {
            // Arrange
            const order = {
                isUnverified: false,
                policy: {
                    noCoverage: false,
                    isITAC: false
                },
                currentDeductible: 100,
                lineItems: defaultLineItems
            };

            // Act
            const result = getCartTotal(order);

            // Assert
            expect(result).toBe(325);
        });

        test('Returns total of all line items when verified no comp', () => {
            // Arrange
            const order = {
                isUnverified: false,
                policy: {
                    noCoverage: true,
                    isITAC: false
                },
                currentDeductible: 0,
                lineItems: defaultLineItems
            };

            // Act
            const result = getCartTotal(order);

            // Assert
            expect(result).toBe(351);
        });

        test('Returns total of all line items when verified ITAC', () => {
            // Arrange
            const order = {
                isUnverified: false,
                policy: {
                    noCoverage: false,
                    isITAC: true
                },
                currentDeductible: 0,
                lineItems: defaultLineItems
            };

            // Act
            const result = getCartTotal(order);

            // Assert
            expect(result).toBe(351);
        });
    });
});