import { validateAddresses } from '../shared/utils/validateAddresses';
import type { DefaultShippingSettings } from '../types';
import type { Order } from '../types';

function makeStore( overrides: Partial<DefaultShippingSettings> = {} ): DefaultShippingSettings {
	return {
		property: '12',
		street: 'Baker Street',
		town: 'London',
		country: 'GB',
		postcode: 'NW1 6XE',
		contactName: 'Test Store',
		phone: '07700000000',
		organisation: '',
		county: '',
		email: '',
		...overrides,
	};
}

function makeOrder( shippingOverrides: Partial<any> = {}, customerOverrides: Partial<any> = {} ): Order {
	return {
		shipping: {
			address_1: '5 High Street',
			city: 'Manchester',
			postcode: 'M1 1AA',
			country: 'GB',
			name: 'John Smith',
			phone: '07700000001',
			...shippingOverrides,
		},
		customer: {
			email: 'test@example.com',
			...customerOverrides,
		},
	} as unknown as Order;
}

describe( 'validateAddresses', () => {
	// ---- Positive tests ----

	it( 'returns valid=true when store and order are both complete', () => {
		const result = validateAddresses( makeStore(), makeOrder() );
		expect( result.valid ).toBe( true );
		expect( result.storeMissing ).toHaveLength( 0 );
		expect( result.customerMissing ).toHaveLength( 0 );
	} );

	it( 'returns valid=true when order is null — only validates store', () => {
		const result = validateAddresses( makeStore(), null );
		expect( result.valid ).toBe( true );
		expect( result.customerMissing ).toHaveLength( 0 );
	} );

	it( 'returns empty customerMissing when order is null', () => {
		expect( validateAddresses( makeStore(), null ).customerMissing ).toEqual( [] );
	} );

	// ---- Store negative tests ----

	it( 'flags missing postcode in store', () => {
		const result = validateAddresses( makeStore( { postcode: '' } ), null );
		expect( result.valid ).toBe( false );
		expect( result.storeMissing ).toContain( 'Postcode' );
	} );

	it( 'flags missing contactName in store', () => {
		const result = validateAddresses( makeStore( { contactName: '' } ), null );
		expect( result.storeMissing ).toContain( 'Contact name' );
	} );

	it( 'flags missing town in store', () => {
		const result = validateAddresses( makeStore( { town: '' } ), null );
		expect( result.storeMissing ).toContain( 'Town' );
	} );

	it( 'flags missing country in store', () => {
		const result = validateAddresses( makeStore( { country: '' } ), null );
		expect( result.storeMissing ).toContain( 'Country' );
	} );

	it( 'flags multiple missing store fields at once', () => {
		const result = validateAddresses( makeStore( { property: '', street: '' } ), null );
		expect( result.storeMissing.length ).toBeGreaterThanOrEqual( 2 );
	} );

	it( 'returns a generic store error when store is null', () => {
		const result = validateAddresses( null, null );
		expect( result.storeMissing.length ).toBeGreaterThan( 0 );
		expect( result.valid ).toBe( false );
	} );

	it( 'treats whitespace-only store field as missing', () => {
		const result = validateAddresses( makeStore( { postcode: '   ' } ), null );
		expect( result.storeMissing ).toContain( 'Postcode' );
	} );

	// ---- Order negative tests ----

	it( 'flags missing address_1 in order', () => {
		const result = validateAddresses( makeStore(), makeOrder( { address_1: '' } ) );
		expect( result.customerMissing ).toContain( 'Address line 1' );
		expect( result.valid ).toBe( false );
	} );

	it( 'flags missing city in order', () => {
		const result = validateAddresses( makeStore(), makeOrder( { city: '' } ) );
		expect( result.customerMissing ).toContain( 'City' );
	} );

	it( 'flags missing recipient name in order', () => {
		const result = validateAddresses( makeStore(), makeOrder( { name: '' } ) );
		expect( result.customerMissing ).toContain( 'Recipient name' );
	} );

	it( 'flags missing customer email', () => {
		const result = validateAddresses( makeStore(), makeOrder( {}, { email: '' } ) );
		expect( result.customerMissing ).toContain( 'Customer email' );
	} );

	it( 'flags missing recipient phone', () => {
		const result = validateAddresses( makeStore(), makeOrder( { phone: '' } ) );
		expect( result.customerMissing ).toContain( 'Recipient phone' );
	} );

	it( 'flags missing order country', () => {
		const result = validateAddresses( makeStore(), makeOrder( { country: '' } ) );
		expect( result.customerMissing ).toContain( 'Country' );
	} );

	it( 'treats whitespace-only order field as missing', () => {
		const result = validateAddresses( makeStore(), makeOrder( { address_1: '   ' } ) );
		expect( result.customerMissing ).toContain( 'Address line 1' );
	} );
} );