import { computeFinalPrice, computeProtectedAmount, buildExtras } from '../features/order-ship/utils/quotePrice';
import type { Quote } from '../types';

const baseExtra = {
	key: 'protection:base',
	price: { net: 200, gross: 240 },
	metadata: { protectedAmount: 100 },
};
const fullExtra = {
	key: 'protection:full',
	price: { net: 500, gross: 600 },
	metadata: { protectedAmount: 500 },
};

function makeQuote( extras: any[] = [], overrides: Partial<any> = {} ): Quote {
	return {
		price: { net: 1000, gross: 1200 },
		availableExtras: extras,
		service: { includedProtection: 50 },
		...overrides,
	} as unknown as Quote;
}

// -------------------------------------------------------------------------
describe( 'computeFinalPrice', () => {
	// Positive
	it( 'returns base price / 100 when no extras available', () => {
		const result = computeFinalPrice( makeQuote(), false );
		expect( result.net ).toBeCloseTo( 10 );
		expect( result.gross ).toBeCloseTo( 12 );
	} );

	it( 'adds base protection cost when fullyProtection=false and base available', () => {
		const result = computeFinalPrice( makeQuote( [ baseExtra ] ), false );
		expect( result.net ).toBeCloseTo( ( 1000 + 200 ) / 100 );
		expect( result.gross ).toBeCloseTo( ( 1200 + 240 ) / 100 );
	} );

	it( 'adds full protection cost when fullyProtection=true and full available', () => {
		const result = computeFinalPrice( makeQuote( [ baseExtra, fullExtra ] ), true );
		expect( result.net ).toBeCloseTo( ( 1000 + 500 ) / 100 );
		expect( result.gross ).toBeCloseTo( ( 1200 + 600 ) / 100 );
	} );

	// Negative
	it( 'falls back to base when fullyProtection=true but only base available', () => {
		const result = computeFinalPrice( makeQuote( [ baseExtra ] ), true );
		expect( result.net ).toBeCloseTo( ( 1000 + 200 ) / 100 );
	} );

	it( 'returns raw price when no extras present at all', () => {
		const result = computeFinalPrice( makeQuote( [] ), true );
		expect( result.net ).toBeCloseTo( 10 );
	} );
} );

// -------------------------------------------------------------------------
describe( 'computeProtectedAmount', () => {
	// Positive
	it( 'returns service.includedProtection when no extras', () => {
		expect( computeProtectedAmount( makeQuote(), false ) ).toBe( 50 );
	} );

	it( 'returns base protection metadata amount', () => {
		expect( computeProtectedAmount( makeQuote( [ baseExtra ] ), false ) ).toBe( 100 );
	} );

	it( 'returns full protection metadata amount when requested', () => {
		expect( computeProtectedAmount( makeQuote( [ baseExtra, fullExtra ] ), true ) ).toBe( 500 );
	} );

	// Negative
	it( 'returns base amount when full requested but unavailable', () => {
		expect( computeProtectedAmount( makeQuote( [ baseExtra ] ), true ) ).toBe( 100 );
	} );

	it( 'returns includedProtection=0 when service has no protection and no extras', () => {
		const quote = makeQuote( [], { service: { includedProtection: 0 } } );
		expect( computeProtectedAmount( quote, false ) ).toBe( 0 );
	} );
} );

// -------------------------------------------------------------------------
describe( 'buildExtras', () => {
	// Positive
	it( 'includes "protection:base" when base available and fullyProtection=false', () => {
		expect( buildExtras( makeQuote( [ baseExtra ] ), false ) ).toContain( 'protection:base' );
	} );

	it( 'includes "protection:full" when full available and fullyProtection=true', () => {
		const extras = buildExtras( makeQuote( [ baseExtra, fullExtra ] ), true );
		expect( extras ).toContain( 'protection:full' );
		expect( extras ).not.toContain( 'protection:base' );
	} );

	// Negative
	it( 'returns empty array when no extras available', () => {
		expect( buildExtras( makeQuote( [] ), false ) ).toEqual( [] );
	} );

	it( 'falls back to base when full requested but unavailable', () => {
		const extras = buildExtras( makeQuote( [ baseExtra ] ), true );
		expect( extras ).toContain( 'protection:base' );
		expect( extras ).not.toContain( 'protection:full' );
	} );
} );