import { sendCommandRequest, sendMessage } from '../handlers/ws_messageSender';
import { get } from 'svelte/store';
import { auth } from '../stores/auth';
import {
	productCodesLoading,
	hasSheetPriceBeenSent,
	markSheetPriceAsSent,
	sheetPriceLoading,
	streamingRawData,
	setPendingProductCodesCountry,
	setPendingPriceSlotsCountry,
	priceSlotsLoading,
	resetPriceSlotsCountry
} from '../stores/sheetStore';
import type { PriceSlot } from '../stores/sheetStore';
import { setGenLayoutGenerating } from '../stores/genLayoutStore';

export async function requestCatalogs(country: string): Promise<boolean> {
	return await sendCommandRequest('sheet', {
		country: country,
		param: 'catalogs'
	});
}

export async function requestPriceSlots(country: string): Promise<boolean> {
	setPendingPriceSlotsCountry(country);
	resetPriceSlotsCountry(country);
	const request_id = crypto.randomUUID();

	streamingRawData.update((data) => ({
		...data,
		priceslot: {
			request_id,
			country,
			chunks: [],
			rawParts: []
		}
	}));
	priceSlotsLoading.set(true);

	const values = {
		country: country,
		param: 'price',
		option: 'PriceSlot',
		stream: true,
		request_id
	};
	console.log('[sheetService] Sending PriceSlot request:', values);
	const sent = await sendCommandRequest('sheet', values);
	console.log('[sheetService] PriceSlot request sent:', sent);
	if (!sent) {
		priceSlotsLoading.set(false);
	}
	return sent;
}

export async function updatePriceSlot(country: string, content: PriceSlot): Promise<boolean> {
	return await sendCommandRequest('sheet', {
		country: country,
		content: content,
		param: 'update/priceslot'
	});
}

export async function enterRoom(country: string, catalog: string): Promise<boolean> {
	return await sendCommandRequest('sheet', {
		country: country,
		catalog: catalog,
		param: 'enter'
	});
}

export async function sendHeartbeat(country: string, catalog: string): Promise<boolean> {
	return await sendCommandRequest('sheet', {
		country: country,
		catalog: catalog,
		param: 'heartbeat'
	});
}

export async function exitRoom(country: string, catalog: string): Promise<boolean> {
	return await sendCommandRequest('sheet', {
		country: country,
		catalog: catalog,
		param: 'exit'
	});
}

export async function requestCatalogMenu(country: string, catalog: string): Promise<boolean> {
	return await sendCommandRequest('sheet', {
		country: country,
		catalog: catalog,
		param: 'catalog/menu'
	});
}

export async function updateMenu(
	country: string,
	catalog: string,
	content: any[]
): Promise<boolean> {
	return await sendCommandRequest('sheet', {
		country: country,
		catalog: catalog,
		content: content,
		param: 'update/menu'
	});
}

export async function addMenu(country: string, catalog: string, content: any[]): Promise<boolean> {
	console.log('[sheetService] Adding menu:', { country, catalog, content });
	const sent = await sendCommandRequest('sheet', {
		country: country,
		catalog: catalog,
		content: content,
		param: 'add/menu'
	});
	console.log('[sheetService] Add menu sent:', sent);
	return sent;
}

export async function deleteMenu(
	country: string,
	catalog: string,
	targetIds: number[]
): Promise<boolean> {
	const content = targetIds.map((id) => ({ target_id: id }));
	return await sendCommandRequest('sheet', {
		country: country,
		catalog: catalog,
		content: content,
		param: 'delete/menu'
	});
}

export async function swapMenu(
	country: string,
	catalog: string,
	swaps: { source_id: number; target_id: number }[]
): Promise<boolean> {
	return await sendCommandRequest('sheet', {
		country: country,
		catalog: catalog,
		content: swaps,
		param: 'swap/menu'
	});
}

export async function requestListMenu(country: string, boxid?: string): Promise<boolean> {
	const curr_user = get(auth);

	let user_info: any = {};
	if (curr_user) {
		user_info = {
			displayName: curr_user.displayName,
			email: curr_user.email,
			uid: curr_user.uid
		};
	}

	productCodesLoading.set(true);
	setPendingProductCodesCountry(country);

	console.log('[sheetService] Sending list_menu request for country:', country, 'boxid:', boxid);

	return await sendMessage({
		type: 'list_menu',
		payload: {
			user_info,
			country,
			boxid: boxid || undefined
		}
	});
}

export async function requestGenLayout(country: string): Promise<boolean> {
	const curr_user = get(auth);

	let user_info: any = {};
	if (curr_user) {
		user_info = {
			displayName: curr_user.displayName,
			email: curr_user.email,
			uid: curr_user.uid
		};
	}

	setGenLayoutGenerating();

	console.log('[sheetService] Sending gen-layout request for country:', country);

	return await sendMessage({
		type: 'command',
		payload: {
			user_info,
			srv_name: 'gen-service',
			values: {
				file_layout: 'sheet',
				file_desc: 'sheet',
				country: country,
				param: 'new-inter-v3-multi-promotion-other_catalog-supra_app'
			}
		}
	});
}

/**
 * Request price data from sheet for specific product codes
 * NOTE: Can only send once per type (price). Use hasSheetPriceBeenSent to check.
 */
export async function requestSheetPrice(country: string, productCodes: string[]): Promise<boolean> {
	// Check if already sent
	if (hasSheetPriceBeenSent('price')) {
		console.warn('[sheetService] Price request already sent, skipping');
		return false;
	}

	if (!productCodes || productCodes.length === 0) {
		console.warn('[sheetService] No product codes to request price for');
		return false;
	}

	// Generate request_id (UUID v4)
	const request_id = crypto.randomUUID();

	// Store request_id and country in streamingRawData for tracking
	streamingRawData.update((data) => ({
		...data,
		price: {
			request_id,
			country,
			chunks: [],
			rawParts: []
		}
	}));

	sheetPriceLoading.set(true);

	// Convert to array of objects (backend expects objects, not strings)
	const content = productCodes.map((code) => ({ product_code: code }));

	console.log(
		'[sheetService] Sending sheet price request for country:',
		country,
		'codes:',
		productCodes.length,
		'request_id:',
		request_id
	);

	const sent = await sendCommandRequest('sheet', {
		country: country,
		content: content,
		param: 'price',
		stream: true,
		request_id
	});

	if (sent) {
		markSheetPriceAsSent('price');
	} else {
		sheetPriceLoading.set(false);
	}

	return sent;
}

/**
 * Update price data in sheet
 * content: [{ row_index: number, cells: [{ value: string, coord: { row: number, col: number } }] }]
 */
export async function updateSheetPrice(
	country: string,
	content: { row_index: number; cells: { value: string; coord: { row: number; col: number } }[] }[]
): Promise<boolean> {
	if (!content || content.length === 0) {
		console.warn('[sheetService] No content to update');
		return false;
	}

	console.log(
		'[sheetService] Updating sheet price for country:',
		country,
		'items:',
		content.length
	);

	return await sendCommandRequest('sheet', {
		country: country,
		content: content,
		param: 'update/price'
	});
}

/**
 * Add new price rows to sheet (for product codes that don't exist in price sheet)
 * content: [{ cells: [product_code, name_en, name_th, ..., price, ...] }]
 */
export async function addSheetPrice(
	country: string,
	content: { cells: string[] }[]
): Promise<boolean> {
	if (!content || content.length === 0) {
		console.warn('[sheetService] No content to add');
		return false;
	}

	console.log(
		'[sheetService] Adding price rows for country:',
		country,
		'items:',
		content.length,
		content
	);

	return await sendCommandRequest('sheet', {
		country: country,
		content: content,
		param: 'add/price'
	});
}