<script lang="ts">
	import { untrack } from 'svelte';
	import { goto, invalidateAll } from '$app/navigation';
	import * as Tabs from '$lib/components/ui/tabs';
	import { Button } from '$lib/components/ui/button';
	import { toast } from 'svelte-sonner';
	import { Badge } from '$lib/components/ui/badge';
	import { Separator } from '$lib/components/ui/separator';
	import {
		ArrowLeft,
		CircleAlert,
		CircleCheck,
		FileText,
		MessageSquare,
		FileSpreadsheet,
		Package,
		Box,
		Download,
		Coins,
		Wallet,
		FileStack,
		Scan,
		LoaderCircle,
		Save
	} from 'lucide-svelte';
	import { useSidebar } from '$lib/components/ui/sidebar/context.svelte';
	import { useShortcuts } from '$lib/hooks/use-shortcuts';
	import { focusStore, interactionMode } from '$lib/stores/focus-store';
	import { obtenerAtajosPrincipalesEdicionPedimento } from '$lib/config/shortcuts/dashboard/pedimentos/edit';

	// Importar los componentes de cada pestaña (ahora sin botones de guardar propios)
	import GeneralTabForm from '$lib/components/dashboard/pedimentos/edit/general-tab-form.svelte';
	import DatesTabForm from '$lib/components/dashboard/pedimentos/edit/dates-tab-form.svelte';
	import FacturasTabForm from '$lib/components/dashboard/pedimentos/edit/invoices-tab-form.svelte';
	import PartidasTabForm from '$lib/components/dashboard/pedimentos/edit/items-tab-form.svelte';
	import BultosTransportesTabForm from '$lib/components/dashboard/pedimentos/edit/package-transportation-tab-form.svelte';
	import DescargasTabForm from '$lib/components/dashboard/pedimentos/edit/discharge-tab-form.svelte';
	import ContribucionesTabForm from '$lib/components/dashboard/pedimentos/edit/contributions-tab-form.svelte';
	import CuentasCompensacionTabForm from '$lib/components/dashboard/pedimentos/edit/accounts-compensation-tab-form.svelte';
	import DigitalizacionTabForm from '$lib/components/dashboard/pedimentos/edit/digitization-tab-form.svelte';
	import OtrosDatosTabForm from '$lib/components/dashboard/pedimentos/edit/other-data-tab-form.svelte';
	import PaymentsTabForm from '$lib/components/dashboard/pedimentos/edit/payments-tab-form.svelte';
	import TransportTabForm from '$lib/components/dashboard/pedimentos/edit/transport-tab-form.svelte';
	import ValidationTabForm from '$lib/components/dashboard/pedimentos/edit/validation-tab-form.svelte';

	// Importar solo la API de pedimentos
	import {
		pedimentosApi,
		type CreatePedimentoData,
		type UpdatePedimentoData
	} from '$lib/api/dashboard/a76/pedimentos';
	import type { PedimentoCode } from '$lib/api/dashboard/reference_data/pedimento_codes';
	import type { CustomsSection } from '$lib/api/dashboard/reference_data/customs_sections';
	import type { CustomsBroker } from '$lib/api/dashboard/a76/customs-brokers';
	import type { ClientProvider } from '$lib/api/dashboard/a76/clients-providers';
	import type { CodePedimentoRegimen } from '$lib/api/dashboard/reference_data/code_pedimento_regimens';
	import type { TransportType } from '$lib/api/dashboard/reference_data/transport_types';
	import type { TransportMode } from '$lib/api/dashboard/reference_data/transport_modes';
	type PedimentoTransportCatalog = {
		code: string;
		transport_en: string;
		transport_es: string;
		payment_date_code: 'E' | 'P' | string;
	};

	// Get sidebar context
	const sidebar = useSidebar();

	interface ExtendedPageData {
		pedimentoId?: number | null;
		pedimento?: any;
		isCreate?: boolean;
		pedimentoCodes?: PedimentoCode[];
		customsSections?: CustomsSection[];
		customsBrokers?: CustomsBroker[];
		clients?: ClientProvider[];
		codePedimentoRegimens?: CodePedimentoRegimen[];
		transportTypes?: TransportType[];
		transportModes?: TransportMode[];
		pedimentoTransportCatalog?: PedimentoTransportCatalog[];
		user?: any;
		companies?: any[];
		authenticated?: boolean;
	}

	import { companyStore } from '$lib/stores/company.svelte';
	import PrerequisitesModal from '$lib/components/dashboard/PrerequisitesModal.svelte';
	import { currentUser } from '$lib/auth';
	import ErrorState from '$lib/components/dashboard/common/error-state.svelte';
	import { canAccessPedimentoEditorPage } from '$lib/permissions/pedimento-permissions';

	let { data }: { data: ExtendedPageData } = $props();

	const canUsePedimentoEditor = $derived(
		canAccessPedimentoEditorPage($currentUser, !!data.isCreate)
	);

	let activeTab = $state('general');

	// Focus first input when switching main tabs (mouse or shortcut)

	$effect(() => {
		// Accedemos a activeTab para que el efecto dependa de él
		if (activeTab) {
			// Usamos untrack para que no dependa de interactionMode
			// Esto evita que se dispare el foco al empezar a escribir (cambio de mouse a keyboard)
			const mode = untrack(() => {
				let currentMode;
				interactionMode.subscribe((v) => (currentMode = v))();
				return currentMode;
			});

			if (mode === 'keyboard') {
				focusStore.request('first-input');
			}
		}
	});
	let generalTabInstance = $state<any>(null); // Todavía útil para otras cosas
	let saving = $state(false);

	useShortcuts(
		'Pedimento Edit Main Tabs',
		obtenerAtajosPrincipalesEdicionPedimento({
			cambiarPestana: (tab) => (activeTab = tab),
			manejarGuardar: handleSaveAll,
			manejarRegresar: handleBack
		})
	);

	// Prerrequisitos: modal solo en creación cuando no hay agentes o clientes
	const agentsCount = $derived(data.customsBrokers?.length ?? 0);
	const clientsCount = $derived(data.clients?.length ?? 0);
	let showPrerequisitesModal = $state(false);
	let hasTriedToShowPrerequisitesModal = $state(false);
	$effect(() => {
		if (hasTriedToShowPrerequisitesModal) return;
		if (!data.isCreate) return;
		if (agentsCount === 0 || clientsCount === 0) {
			hasTriedToShowPrerequisitesModal = true;
			showPrerequisitesModal = true;
		}
	});

	function normalizeDateValue(value: string | null | undefined): string | null {
		if (!value) return null;
		return value.includes('T') ? value.slice(0, 10) : value;
	}

	function validateLegacyDateConsistency(formData: any): boolean {
		const startDate = normalizeDateValue(formData?.start_date);
		const endDate = normalizeDateValue(formData?.end_date);
		const entryDate = normalizeDateValue(formData?.entry_date);
		const paymentDate = normalizeDateValue(formData?.payment_date);
		const referenceDate = paymentDate || entryDate;
		const pedimentoType = formData?.pedimento_type;
		const isConsolidated = pedimentoType === 'consolidated';
		const isIndividual = pedimentoType === 'normal';

		if (!startDate || !endDate || !referenceDate) return true;

		// Legacy Clarion (CON): inicio <= fin <= fecha de referencia (pago / entrada)
		if (isConsolidated) {
			if (startDate > endDate) {
				toast.error(
					`La fecha inicio (${startDate}) no puede ser mayor que la fecha final (${endDate}).`
				);
				activeTab = 'general';
				return false;
			}

			if (startDate > referenceDate) {
				toast.error(
					`La fecha inicio (${startDate}) no puede ser mayor que la fecha de referencia (${referenceDate}).`
				);
				activeTab = 'general';
				return false;
			}

			if (endDate > referenceDate) {
				toast.error(
					`La fecha final (${endDate}) no puede ser mayor que la fecha de referencia (${referenceDate}).`
				);
				activeTab = 'general';
				return false;
			}
		}

		// Legacy Clarion (IND): advertencia si las fechas no coinciden, sin bloqueo.
		if (isIndividual && (startDate !== endDate || startDate !== referenceDate)) {
			toast.warning(
				'Advertencia: en pedimento individual las fechas inicio/final/referencia son distintas.'
			);
		}

		return true;
	}

	// ID del pedimento
	let pedimentoId = $state<number | null>(data.pedimentoId ?? null);

	const pedimento = data.pedimento;

	// Referencias a los componentes de formulario para obtener sus datos
	let generalFormData = $state<any>(null);
	let observacionesFormData = $state<any>(null);
	let facturasFormData = $state<any>(null);
	let partidasFormData = $state<any>({ partidas: [], convertir_uma_umc: false });
	let bultosTransportesFormData = $state<any>({
		bultos: { cantidad: 0, marcas: 'S/M', numero: 'S/N', vehiculos: 1 },
		transportes: [],
		precintos: [],
		contenedores: []
	});
	let descargasFormData = $state<any>({ descargos: [], destinatarios: [] });
	let contribucionesFormData = $state<any>({
		dta: { forma_pago_recargo: 0, tasa_recargo: 0.0, importe_recargo: 0 },
		prev: { forma_pago_prevalidacion: 0 },
		eci: { forma_pago_eci: 0, importe_eci: 0 },
		mult: { forma_pago_multa: 0, importe_multa: 0 },
		rec: { forma_pago_uia: 0, importe_compensar: 0 },
		calculo_manual: false,
		operaciones_regla_31_40: false,
		contribuciones: []
	});
	let cuentasCompensacionFormData = $state<any>({
		cuentas_garantia: [],
		compensaciones: [],
		documentos_pago: []
	});
	let digitalizacionFormData = $state<{ digitalizaciones: any[] }>({
		digitalizaciones: []
	});
	let identificadoresFormData = $state({
		identificadores: []
	});
	let otrosDatosFormData = $state({
		tipo_calculo: 'ninguno',
		dta_por_operacion_ag_facturas: false,
		dta_por_numero_vehiculos: false,
		paga_iva: false,
		paga_prevalidacion: false,
		aplicar_dta_8_millar_partida: false,
		incluir_eci: false,
		deducible_recargos: false,
		cuota_fija_adicional_vehiculo: false,
		cuota_fija_adicional_fp: '0',
		actualizar_iva: false,
		actualizar_advalorem: false,
		actualizar_dta: false,
		actualizar_cc: false,
		actualizar_ieps: false,
		es_embajada: false,
		embajada_dta: '0.00',
		regla_3_1_21_factores: false,
		cambio_tarifa_anterior: '',
		actualizar_iva_rect: false,
		actualizar_advalorem_rect: false,
		actualizar_dta_rect: false,
		actualizar_cc_rect: false,
		actualizar_ieps_rect: false,
		calcular_recargos_diferencias: false,
		es_rectificacion: '',
		pedimento_original: '',
		clave_pedimento_original: '',
		fecha_pago_original: '',
		anio_impresion_rect: '',
		aduana_seccion_original: '',
		patente_original: '',
		utilizar_fecha_pago_original: false,
		calculo_manual_contribuciones: false,
		causa: '',
		motivo: '',
		liquidacion_diferencias: [],
		proveedor_nacional_modifico_dta: false,
		calculo_valor_aduana_v2: false,
		calculo_2_decimales_valor_unitario: false,
		calcular_valor_aduana_base_partidas: false,
		recargo_igi: false,
		recargo_iva: false,
		recargo_ieps: false,
		recargo_isan: false,
		recargo_cc: false,
		factor_incrementable_manual: '0.00000000000000000000',
		agregar_entidad_federativa_proveedor: false
	});

	// Flag para evitar loops infinitos en el effect
	let otrosDatosLoaded = false;
	let lastPedimentoId: number | null = null;

	// Cargar datos del pedimento en otrosDatosFormData cuando data.pedimento está disponible
	// Solo ejecutar una vez cuando el pedimento cambia
	$effect(() => {
		// Solo rastrear data.pedimento?.id para evitar re-ejecuciones innecesarias
		const pedimentoId = data.pedimento?.id ?? null;

		// Si el ID del pedimento cambió, resetear el flag
		if (pedimentoId !== lastPedimentoId) {
			lastPedimentoId = pedimentoId;
			otrosDatosLoaded = false;
		}

		if (data.pedimento && !data.isCreate && !otrosDatosLoaded) {
			otrosDatosLoaded = true;
			const pedimento = data.pedimento;

			// Mapear pedimento_config_calculations
			if (pedimento.pedimento_config_calculations) {
				const calc = pedimento.pedimento_config_calculations;
				otrosDatosFormData.dta_por_operacion_ag_facturas = calc.dta_operation ?? false;
				otrosDatosFormData.dta_por_numero_vehiculos = calc.dta_vehicle_count ?? false;
				otrosDatosFormData.paga_iva = calc.pays_vat ?? false;
				otrosDatosFormData.paga_prevalidacion = calc.pays_prevalidation ?? false;
				otrosDatosFormData.aplicar_dta_8_millar_partida = calc.dta_mixed_rate_8permil ?? false;
				otrosDatosFormData.incluir_eci = calc.include_sagar_certificate_fee ?? false;
				otrosDatosFormData.cuota_fija_adicional_vehiculo = calc.fixed_vehicle_dta_fee ?? false;
				otrosDatosFormData.cuota_fija_adicional_fp = calc.additional_fixed_fee?.toString() || '0';

				if (calc.dta_type === '1') {
					otrosDatosFormData.tipo_calculo = 'Cuota fija';
				} else if (calc.dta_type === '2') {
					otrosDatosFormData.tipo_calculo = '8 al millar';
				} else if (calc.dta_type === '3') {
					otrosDatosFormData.tipo_calculo = '1.76 al millar';
				} else if (calc.dta_type === '4') {
					otrosDatosFormData.tipo_calculo = 'Estados extranjeros';
				} else {
					otrosDatosFormData.tipo_calculo = 'ninguno';
				}
			}

			// Mapear pedimento_config_parameters
			if (pedimento.pedimento_config_parameters) {
				const params = pedimento.pedimento_config_parameters;
				otrosDatosFormData.es_embajada = params.is_embassy ?? false;
				otrosDatosFormData.embajada_dta = params.embassy_dta || '0.00';
				otrosDatosFormData.regla_3_1_21_factores = params.rule_3121_section_ii ?? false;
				otrosDatosFormData.cambio_tarifa_anterior = params.use_previous_tariff ? 'true' : '';
				otrosDatosFormData.agregar_entidad_federativa_proveedor =
					params.add_state_supplier_record_505 ?? false;
				otrosDatosFormData.calculo_valor_aduana_v2 = params.customs_value_calculation ?? false;
				otrosDatosFormData.calculo_2_decimales_valor_unitario =
					params.two_decimals_unit_value ?? false;
				otrosDatosFormData.calcular_valor_aduana_base_partidas =
					params.customs_value_per_item ?? false;
				otrosDatosFormData.proveedor_nacional_modifico_dta = params.is_national_supplier ?? false;
			}

			// Mapear pedimento_config_updates
			if (pedimento.pedimento_config_updates) {
				const updates = pedimento.pedimento_config_updates;
				otrosDatosFormData.actualizar_iva = updates.update_vat ?? false;
				otrosDatosFormData.actualizar_advalorem = updates.update_advalorem ?? false;
				otrosDatosFormData.actualizar_dta = updates.update_dta ?? false;
				otrosDatosFormData.actualizar_cc = updates.update_cc ?? false;
				otrosDatosFormData.actualizar_ieps = updates.update_ieps ?? false;
			}

			// Mapear pedimento_config_update_rectification
			if (pedimento.pedimento_config_update_rectification) {
				const rect = pedimento.pedimento_config_update_rectification;
				otrosDatosFormData.actualizar_iva_rect = rect.update_vat ?? false;
				otrosDatosFormData.actualizar_advalorem_rect = rect.update_advalorem ?? false;
				otrosDatosFormData.actualizar_dta_rect = rect.update_dta ?? false;
				otrosDatosFormData.actualizar_cc_rect = rect.update_cc ?? false;
				otrosDatosFormData.actualizar_ieps_rect = rect.update_ieps ?? false;
				otrosDatosFormData.calcular_recargos_diferencias = rect.calculate_surcharge ?? false;
			}

			// Mapear pedimento_rectification_origin
			if (pedimento.pedimento_rectification_origin) {
				const origin = pedimento.pedimento_rectification_origin;
				otrosDatosFormData.es_rectificacion = 'si';
				otrosDatosFormData.clave_pedimento_original = origin.original_pedimento_code || '';
				otrosDatosFormData.pedimento_original = origin.original_pedimento_number || '';
				otrosDatosFormData.fecha_pago_original = origin.original_payment_date
					? origin.original_payment_date.split('T')[0]
					: '';
				otrosDatosFormData.aduana_seccion_original = origin.original_customs_office || '';
				otrosDatosFormData.patente_original = origin.original_license || '';
				otrosDatosFormData.utilizar_fecha_pago_original =
					origin.use_original_payment_date_for_interest_calc === 1;
				otrosDatosFormData.calculo_manual_contribuciones = origin.manual_calculation === 1;
				otrosDatosFormData.causa = origin.reason || '';
				otrosDatosFormData.motivo = origin.reason || '';
				// El año suele ser los primeros 2 dígitos del pedimento original
				otrosDatosFormData.anio_impresion_rect = origin.original_pedimento_year || '';
			} else {
				otrosDatosFormData.es_rectificacion = 'no';
			}

			// Mapear pedimento_config_surcharges
			if (pedimento.pedimento_config_surcharges) {
				const surcharges = pedimento.pedimento_config_surcharges;
				otrosDatosFormData.recargo_igi = surcharges.surcharge_igi ?? false;
				otrosDatosFormData.deducible_recargos = surcharges.surcharge_dta ?? false;
				otrosDatosFormData.recargo_iva = surcharges.surcharge_vat ?? false;
				otrosDatosFormData.recargo_ieps = surcharges.surcharge_ieps ?? false;
				otrosDatosFormData.recargo_isan = surcharges.surcharge_isan ?? false;
				otrosDatosFormData.recargo_cc = surcharges.surcharge_cc ?? false;
			}
		}
	});

	// Estados para saber si existen datos previos (para compatibilidad con componentes hijos)
	let observacionesExists = $state(false);
	let facturasExists = $state(false);
	let partidasExists = $state(false);
	let bultosTransportesExists = $state(false);
	let descargasExists = $state(false);
	let contribucionesExists = $state(false);
	let cuentasCompensacionExists = $state(false);
	let otrosDatosExists = $state(false);
	let digitalizacionExists = $state(false);

	function handleBack() {
		goto('/dashboard/pedimentos');
	}

	function getStatusColor(
		status?: string | null
	): 'default' | 'destructive' | 'outline' | 'secondary' {
		if (!status) return 'secondary';

		const statusLower = status.toLowerCase();
		if (statusLower.includes('activo') || statusLower.includes('completado')) {
			return 'default';
		} else if (statusLower.includes('pendiente') || statusLower.includes('proceso')) {
			return 'secondary';
		} else if (statusLower.includes('cancelado')) {
			return 'destructive';
		}
		return 'outline';
	}

	async function handleSaveAll() {
		saving = true;

		try {
			// Validar campos requeridos para guardar (client_id es opcional)
			if (generalFormData) {
				const requiredFields: Record<string, string> = {
					customs_office: 'Aduana',
					license: 'Patente',
					pedimento_number: 'Número de Pedimento',
					operation_type: 'Tipo de Operación',
					pedimento_type: 'Tipo de Pedimento',
					pedimento_code: 'Clave',
					regime: 'Régimen',
					start_date: 'Fecha de Inicio',
					end_date: 'Fecha Final',
					entry_date: 'Fecha de Entrada'
				};

				const missingFields: string[] = [];
				for (const [field, label] of Object.entries(requiredFields)) {
					const value = (generalFormData as any)[field];
					if (value === null || value === undefined || value === '') {
						missingFields.push(label);
					}
				}

				if (missingFields.length > 0) {
					throw new Error(`Los siguientes campos son obligatorios: ${missingFields.join(', ')}`);
				}
			}

			if (generalFormData && !validateLegacyDateConsistency(generalFormData)) {
				saving = false;
				return;
			}

			// Validar consistencia de la sección de transportes (todos o ninguno)
			if (generalFormData?.pedimento_transport_means) {
				const t = generalFormData.pedimento_transport_means;
				const hasAny = t.destination || t.entry_exit || t.arrival || t.departure;
				const hasAll = t.destination && t.entry_exit && t.arrival && t.departure;

				if (hasAny && !hasAll) {
					const missing = [];
					if (!t.destination) missing.push('Región de Destino');
					if (!t.entry_exit) missing.push('Método de Entrada');
					if (!t.arrival) missing.push('Arribo');
					if (!t.departure) missing.push('Salida');

					toast.error('Sección de Transportes incompleta', {
						description: `Para guardar esta sección, debes completar: ${missing.join(', ')}.`
					});
					saving = false;
					activeTab = 'general';
					return;
				}
			}

			// Construir el payload unificado
			const payload: any = {
				// Datos generales
				year: generalFormData?.year || undefined,
				customs_office: generalFormData?.customs_office || undefined,
				license: generalFormData?.license || undefined,
				pedimento_number: generalFormData?.pedimento_number || undefined,
				client_id: generalFormData?.client_id || undefined,
				operation_type: generalFormData?.operation_type || undefined,
				pedimento_type: generalFormData?.pedimento_type || undefined,
				pedimento_code: generalFormData?.pedimento_code || undefined,
				regime: generalFormData?.regime || undefined,
				status: generalFormData?.status || undefined,
				usd_value: generalFormData?.usd_value || undefined,
				paid_price: generalFormData?.paid_price || undefined,
				gross_weight: generalFormData?.gross_weight || undefined,
				exchange_rate: generalFormData?.exchange_rate || undefined
			};

			// Helper function para convertir fecha YYYY-MM-DD a ISO datetime
			function dateToISO(dateString: string | null | undefined): string | null {
				if (!dateString) return null;
				// Si ya tiene formato ISO completo, retornarlo
				if (dateString.includes('T')) return dateString;
				// Si es solo fecha (YYYY-MM-DD), agregar tiempo medianoche
				return `${dateString}T00:00:00`;
			}

			// Fechas - enviar si hay al menos un campo con valor
			if (generalFormData) {
				const hasDatesValue =
					generalFormData.entry_date ||
					generalFormData.start_date ||
					generalFormData.pedimento_date ||
					generalFormData.extraction_date ||
					generalFormData.rectification_payment_date ||
					generalFormData.original_date ||
					generalFormData.payment_date ||
					generalFormData.end_date;
				if (hasDatesValue) {
					payload.pedimento_dates = {
						entry_date: dateToISO(generalFormData.entry_date),
						start_date: dateToISO(generalFormData.start_date),
						pedimento_date: dateToISO(generalFormData.pedimento_date),
						payment_date: dateToISO(generalFormData.payment_date),
						rectification_payment_date: dateToISO(generalFormData.rectification_payment_date),
						extraction_date: dateToISO(generalFormData.extraction_date),
						original_date: dateToISO(generalFormData.original_date),
						end_date: dateToISO(generalFormData.end_date)
					};
				}

				// Aduanas (Despacho y Entrada/Salida)
				const hasCustomsValue =
					generalFormData.pedimento_customs_offices?.dispatch_customs ||
					generalFormData.pedimento_customs_offices?.entry_exit_customs;
				if (hasCustomsValue) {
					payload.pedimento_customs_offices = {
						dispatch_customs: generalFormData.pedimento_customs_offices.dispatch_customs || null,
						entry_exit_customs: generalFormData.pedimento_customs_offices.entry_exit_customs || null
					};
				}

				// Transportes y Destino
				const hasTransportValue =
					generalFormData.pedimento_transport_means?.destination ||
					generalFormData.pedimento_transport_means?.entry_exit ||
					generalFormData.pedimento_transport_means?.arrival ||
					generalFormData.pedimento_transport_means?.departure;
				if (hasTransportValue) {
					payload.pedimento_transport_means = {
						destination: generalFormData.pedimento_transport_means.destination || null,
						entry_exit: generalFormData.pedimento_transport_means.entry_exit || null,
						arrival: generalFormData.pedimento_transport_means.arrival || '',
						departure: generalFormData.pedimento_transport_means.departure || ''
					};
				}
			}

			// Solo agregar sub-recursos en modo UPDATE (no en CREATE)
			// Y solo si tienen valores reales (no enviar objetos vacíos/null)

			// Observaciones - siempre enviar (puede ser string vacío para borrar)
			payload.observations = observacionesFormData?.observaciones || '';

			// Incrementables - solo enviar si hay al menos un campo con valor
			if (generalFormData) {
				const hasIncrementablesValue =
					generalFormData.valor_seguro ||
					generalFormData.embalajes ||
					generalFormData.fletes ||
					generalFormData.deducibles ||
					generalFormData.moneda_incrementables ||
					generalFormData.no_afectar_valor_dolares_inc !== undefined ||
					generalFormData.no_afectar_valor_aduana !== undefined;
				if (hasIncrementablesValue) {
					payload.pedimento_incrementables = {
						insured_value: generalFormData.valor_seguro || null,
						packaging: generalFormData.embalajes || null,
						freight: generalFormData.fletes || null,
						deductibles: generalFormData.deducibles || null,
						currency: generalFormData.moneda_incrementables || null,
						not_affect_usd_value: generalFormData.no_afectar_valor_dolares_inc || false,
						not_affect_customs_value: generalFormData.no_afectar_valor_aduana || false
					};
				}
			}

			// Decrementables - solo enviar si hay al menos un campo con valor
			if (generalFormData) {
				const hasDecrementablesValue =
					generalFormData.fletes_decrementable ||
					generalFormData.seguros ||
					generalFormData.carga ||
					generalFormData.descarga ||
					generalFormData.otros ||
					generalFormData.moneda_decrementable ||
					generalFormData.afectar_valor_dolares !== undefined;
				if (hasDecrementablesValue) {
					payload.pedimento_decrementables = {
						freight: generalFormData.fletes_decrementable || null,
						insurance: generalFormData.seguros || null,
						loading: generalFormData.carga || null,
						unloading: generalFormData.descarga || null,
						others: generalFormData.otros || null,
						currency: generalFormData.moneda_decrementable || null,
						not_affect_usd_value: generalFormData.afectar_valor_dolares || false
					};
				}
			}

			// Indexes - solo enviar si hay al menos un campo con valor
			if (generalFormData) {
				const hasIndexesValue =
					generalFormData.tipo_factor ||
					generalFormData.factor_actualizacion ||
					generalFormData.factor_actualizacion_manual !== undefined;
				if (hasIndexesValue) {
					// Mapear tipo_factor de string a número
					let updateFactorType = null;
					if (generalFormData.tipo_factor === 'INPC') {
						updateFactorType = 1;
					} else if (generalFormData.tipo_factor === 'variacion_cambiaria') {
						updateFactorType = 2;
					}

					payload.pedimento_indexes = {
						update_factor_type: updateFactorType,
						update_factor: generalFormData.factor_actualizacion || null,
						manual_update_factor: generalFormData.factor_actualizacion_manual || false
					};
				}
			}

			// Config Additional - solo enviar si hay al menos un campo con valor
			if (generalFormData) {
				const hasConfigAdditionalValue =
					generalFormData.anio_impresion ||
					generalFormData.agregar_po_auto !== undefined ||
					generalFormData.no_eximir_normas !== undefined ||
					generalFormData.activar_destinatario !== undefined ||
					generalFormData.agregar_registro_502 !== undefined ||
					generalFormData.agregar_quitar_normas !== undefined ||
					generalFormData.facturar_cove !== undefined;
				if (hasConfigAdditionalValue) {
					payload.pedimento_config_additional = {
						manual_pedimento_year: generalFormData.anio_impresion || null,
						add_po_identifier: generalFormData.agregar_po_auto || false,
						do_not_exempt_norms_complement_x: generalFormData.no_eximir_normas || false,
						enable_import_invoice_recipient: generalFormData.activar_destinatario || false,
						send_502_validation_file_for_consolidated:
							generalFormData.agregar_registro_502 || false,
						add_remove_norms: generalFormData.agregar_quitar_normas || false,
						choose_invoice_cove: generalFormData.facturar_cove || false
					};
				}
			}

			// Identificadores - TEMPORALMENTE DESHABILITADO (no hay soporte en backend)
			// TODO: Implementar tabla de identificadores en el backend
			/*
			if (identificadoresFormData?.identificadores && identificadoresFormData.identificadores.length > 0) {
				payload.identificadores = identificadoresFormData.identificadores;
			}
			*/

			// Config Calculations - configuraciones de cálculo DTA, IVA, prevalidación
			if (otrosDatosFormData) {
				const hasCalculationsValue =
					otrosDatosFormData.tipo_calculo ||
					otrosDatosFormData.dta_por_operacion_ag_facturas !== undefined ||
					otrosDatosFormData.dta_por_numero_vehiculos !== undefined ||
					otrosDatosFormData.paga_iva !== undefined ||
					otrosDatosFormData.paga_prevalidacion !== undefined ||
					otrosDatosFormData.aplicar_dta_8_millar_partida !== undefined ||
					otrosDatosFormData.incluir_eci !== undefined ||
					otrosDatosFormData.cuota_fija_adicional_vehiculo !== undefined ||
					otrosDatosFormData.cuota_fija_adicional_fp;

				if (hasCalculationsValue) {
					// Convertir tipo_calculo a dta_type
					let dtaTypeValue = null;
					if (otrosDatosFormData.tipo_calculo === 'Cuota fija') {
						dtaTypeValue = '1';
					} else if (otrosDatosFormData.tipo_calculo === '8 al millar') {
						dtaTypeValue = '2';
					} else if (otrosDatosFormData.tipo_calculo === '1.76 al millar') {
						dtaTypeValue = '3';
					} else if (otrosDatosFormData.tipo_calculo === 'Estados extranjeros') {
						dtaTypeValue = '4';
					}

					payload.pedimento_config_calculations = {
						dta_type: dtaTypeValue,
						dta_operation: otrosDatosFormData.dta_por_operacion_ag_facturas || false,
						dta_vehicle_count: otrosDatosFormData.dta_por_numero_vehiculos || false,
						dta_mixed_rate_8permil: otrosDatosFormData.aplicar_dta_8_millar_partida || false,
						pays_vat: otrosDatosFormData.paga_iva || false,
						pays_prevalidation: otrosDatosFormData.paga_prevalidacion || false,
						include_sagar_certificate_fee: otrosDatosFormData.incluir_eci || false,
						fixed_vehicle_dta_fee: otrosDatosFormData.cuota_fija_adicional_vehiculo || false,
						additional_fixed_fee: otrosDatosFormData.cuota_fija_adicional_fp
							? parseInt(otrosDatosFormData.cuota_fija_adicional_fp)
							: 0,
						additional_fixed_fee_payment_method: null
					};
				}
			}

			// Config Surcharges - configuraciones de recargos
			if (otrosDatosFormData) {
				const hasSurchargesValue =
					otrosDatosFormData.recargo_igi !== undefined ||
					otrosDatosFormData.deducible_recargos !== undefined ||
					otrosDatosFormData.recargo_iva !== undefined ||
					otrosDatosFormData.recargo_ieps !== undefined ||
					otrosDatosFormData.recargo_isan !== undefined ||
					otrosDatosFormData.recargo_cc !== undefined;

				if (hasSurchargesValue) {
					payload.pedimento_config_surcharges = {
						surcharge_igi: otrosDatosFormData.recargo_igi || false,
						surcharge_dta: otrosDatosFormData.deducible_recargos || false,
						surcharge_vat: otrosDatosFormData.recargo_iva || false,
						surcharge_ieps: otrosDatosFormData.recargo_ieps || false,
						surcharge_isan: otrosDatosFormData.recargo_isan || false,
						surcharge_cc: otrosDatosFormData.recargo_cc || false
					};
				}
			}

			// Config Parameters - parámetros de configuración del pedimento
			if (otrosDatosFormData) {
				const hasParametersValue =
					otrosDatosFormData.es_embajada !== undefined ||
					otrosDatosFormData.embajada_dta ||
					otrosDatosFormData.regla_3_1_21_factores !== undefined ||
					otrosDatosFormData.cambio_tarifa_anterior ||
					otrosDatosFormData.agregar_entidad_federativa_proveedor !== undefined ||
					otrosDatosFormData.calculo_valor_aduana_v2 !== undefined ||
					otrosDatosFormData.calculo_2_decimales_valor_unitario !== undefined ||
					otrosDatosFormData.calcular_valor_aduana_base_partidas !== undefined ||
					otrosDatosFormData.proveedor_nacional_modifico_dta !== undefined;

				if (hasParametersValue) {
					payload.pedimento_config_parameters = {
						is_embassy: otrosDatosFormData.es_embajada || false,
						embassy_dta: otrosDatosFormData.embajada_dta || '0.00',
						rule_3121_section_ii: otrosDatosFormData.regla_3_1_21_factores || false,
						use_previous_tariff: !!otrosDatosFormData.cambio_tarifa_anterior,
						use_payment_date_fi: null,
						add_state_supplier_record_505:
							otrosDatosFormData.agregar_entidad_federativa_proveedor || false,
						customs_value_calculation: otrosDatosFormData.calculo_valor_aduana_v2 || false,
						two_decimals_unit_value: otrosDatosFormData.calculo_2_decimales_valor_unitario || false,
						customs_value_per_item: otrosDatosFormData.calcular_valor_aduana_base_partidas || false,
						is_national_supplier: otrosDatosFormData.proveedor_nacional_modifico_dta || false,
						is_consolidated: null
					};
				}
			}

			// Config Updates - configuraciones de actualización de valores
			if (otrosDatosFormData) {
				const hasUpdatesValue =
					otrosDatosFormData.actualizar_iva !== undefined ||
					otrosDatosFormData.actualizar_advalorem !== undefined ||
					otrosDatosFormData.actualizar_dta !== undefined ||
					otrosDatosFormData.actualizar_cc !== undefined ||
					otrosDatosFormData.actualizar_ieps !== undefined;

				if (hasUpdatesValue) {
					payload.pedimento_config_updates = {
						update_vat: otrosDatosFormData.actualizar_iva || false,
						update_advalorem: otrosDatosFormData.actualizar_advalorem || false,
						update_dta: otrosDatosFormData.actualizar_dta || false,
						update_cc: otrosDatosFormData.actualizar_cc || false,
						update_ieps: otrosDatosFormData.actualizar_ieps || false
					};
				}
			}

			// Config Update Rectification - configuraciones de actualización en rectificación
			if (otrosDatosFormData) {
				const hasUpdateRectValue =
					otrosDatosFormData.actualizar_iva_rect !== undefined ||
					otrosDatosFormData.actualizar_advalorem_rect !== undefined ||
					otrosDatosFormData.actualizar_dta_rect !== undefined ||
					otrosDatosFormData.actualizar_cc_rect !== undefined ||
					otrosDatosFormData.actualizar_ieps_rect !== undefined ||
					otrosDatosFormData.calcular_recargos_diferencias !== undefined;

				if (hasUpdateRectValue) {
					payload.pedimento_config_update_rectification = {
						update_vat: otrosDatosFormData.actualizar_iva_rect || false,
						update_advalorem: otrosDatosFormData.actualizar_advalorem_rect || false,
						update_dta: otrosDatosFormData.actualizar_dta_rect || false,
						update_cc: otrosDatosFormData.actualizar_cc_rect || false,
						update_ieps: otrosDatosFormData.actualizar_ieps_rect || false,
						calculate_surcharge: otrosDatosFormData.calcular_recargos_diferencias || false
					};
				}

				// Rectificación Origin (R1)
				if (otrosDatosFormData.es_rectificacion === 'si') {
					payload.pedimento_rectification_origin = {
						original_pedimento_code: otrosDatosFormData.clave_pedimento_original
							? otrosDatosFormData.clave_pedimento_original.substring(0, 2)
							: null,
						original_pedimento_number: otrosDatosFormData.pedimento_original
							? otrosDatosFormData.pedimento_original.substring(0, 7)
							: null,
						original_payment_date: otrosDatosFormData.fecha_pago_original
							? `${otrosDatosFormData.fecha_pago_original}T00:00:00`
							: null,
						original_customs_office: otrosDatosFormData.aduana_seccion_original
							? otrosDatosFormData.aduana_seccion_original.substring(0, 3)
							: null,
						original_license: otrosDatosFormData.patente_original
							? otrosDatosFormData.patente_original.substring(0, 4)
							: null,
						use_original_payment_date_for_interest_calc:
							otrosDatosFormData.utilizar_fecha_pago_original ? 1 : 0,
						manual_calculation: otrosDatosFormData.calculo_manual_contribuciones ? 1 : 0,
						reason: otrosDatosFormData.motivo || otrosDatosFormData.causa || null,
						original_pedimento_year: otrosDatosFormData.anio_impresion_rect
							? otrosDatosFormData.anio_impresion_rect.substring(0, 2)
							: otrosDatosFormData.pedimento_original
								? otrosDatosFormData.pedimento_original.substring(0, 2)
								: null,
						total_cash: 0,
						total_others: 0,
						charge_to_client: 0,
						original_pedimento_norms: 0
					};
				}
			}

			// Bultos/Transportes - enviar datos de paquetes, transportistas, guías, precintos y contenedores
			if (bultosTransportesFormData) {
				// Paquetes (pedimento_packages) - relación one-to-one
				const bultos = bultosTransportesFormData.bultos;
				if (bultos && (bultos.cantidad || bultos.marcas || bultos.numero || bultos.vehiculos)) {
					payload.pedimento_packages = {
						quantity: bultos.cantidad || null,
						brand: bultos.marcas || null,
						number: bultos.numero || null,
						vehicles: bultos.vehiculos || null
					};
				}

				// Transportistas (pedimento_transport_carriers) - relación one-to-many
				if (
					bultosTransportesFormData.transportes &&
					bultosTransportesFormData.transportes.length > 0
				) {
					payload.pedimento_transport_carriers = bultosTransportesFormData.transportes.map(
						(t: any) => ({
							carrier: t.transportista || null,
							rfc: t.rfc || null,
							curp: t.curp || null,
							name: t.nombre || null,
							address: t.domicilio || null,
							city: t.ciudad || null,
							state: t.estado || null,
							country: t.pais || null,
							tax_id: t.identificacion_fiscal || null,
							total_packages: t.total_bultos || null,
							identification: t.identificacion || null
						})
					);
				}

				// Guías (pedimento_guides) - relación one-to-many
				if (bultosTransportesFormData.guias && bultosTransportesFormData.guias.length > 0) {
					payload.pedimento_guides = bultosTransportesFormData.guias.map((g: any) => ({
						guide: g.guia || null,
						identifier: g.identificador || null
					}));
				}

				// Precintos (pedimento_seals) - relación one-to-many
				if (bultosTransportesFormData.precintos && bultosTransportesFormData.precintos.length > 0) {
					payload.pedimento_seals = bultosTransportesFormData.precintos.map((p: any) => ({
						number: p.numero || null,
						identification: p.identificacion || null
					}));
				}

				// Contenedores (pedimento_containers) - relación one-to-many
				if (
					bultosTransportesFormData.contenedores &&
					bultosTransportesFormData.contenedores.length > 0
				) {
					payload.pedimento_containers = bultosTransportesFormData.contenedores.map((c: any) => ({
						number: c.numero || null,
						identification: c.identificacion || null,
						type: c.tipo || null
					}));
				}
			}

			// Contribuciones - enviar datos de contribuciones generales y diferencias de rectificación
			const baseContribuciones = contribucionesFormData?.contribuciones || [];
			const diffContribuciones = otrosDatosFormData.liquidacion_diferencias || [];

			// Combinar ambas fuentes (evitando duplicados si fuera necesario, pero por ahora concatenar)
			const combinedContribuciones = [
				...baseContribuciones,
				...diffContribuciones.map((d: any) => ({
					gravamen: d.gravamen,
					forma_pago: d.forma_pago,
					importe: parseFloat(d.importe) || 0,
					contribucion: d.gravamen,
					tipo_tasa: '',
					tasa: 0,
					abreviacion: '',
					forma_pago_2: '',
					importe_2: 0
				}))
			];

			if (combinedContribuciones.length > 0) {
				payload.pedimento_contributions = combinedContribuciones.map((c: any) => ({
					contribucion: c.contribucion || null,
					tipo_tasa: c.tipo_tasa || null,
					tasa: c.tasa || null,
					forma_pago: c.forma_pago || null,
					importe: c.importe || null,
					gravamen: c.gravamen || null,
					abreviacion: c.abreviacion || null,
					forma_pago_2: c.forma_pago_2 || null,
					importe_2: c.importe_2 || null
				}));
			}

			// Digitalización - solo enviar si hay digitalizaciones
			if (
				digitalizacionFormData &&
				digitalizacionFormData.digitalizaciones &&
				digitalizacionFormData.digitalizaciones.length > 0
			) {
				(payload as any).digitalizaciones = digitalizacionFormData.digitalizaciones.map(
					(d: any) => ({
						linea: d.linea,
						tipo_documento: d.tipo_documento || null,
						ruta_archivo_pdf: d.ruta_archivo_pdf || null,
						observaciones: d.observaciones || null,
						e_document: d.e_document || null,
						numero_operacion_vu: d.numero_operacion_vu || null
					})
				);
			}

			// Crear una copia limpia del payload para evitar problemas con reactivos de Svelte
			// En lugar de clonar, construimos un objeto nuevo solo con los valores que necesitamos
			const cleanPayload: any = {};

			// Copiar campos del nivel superior
			for (const key in payload) {
				if (payload.hasOwnProperty(key)) {
					const value = payload[key];
					// Si es un valor primitivo o null, copiarlo directamente
					if (value === null || value === undefined || typeof value !== 'object') {
						if (value !== undefined) {
							cleanPayload[key] = value;
						}
					}
					// Si es un array, crear una copia del array
					else if (Array.isArray(value)) {
						cleanPayload[key] = value.map((item: any) => {
							if (item === null || typeof item !== 'object') return item;
							// Para objetos en arrays, crear un nuevo objeto plano
							return { ...item };
						});
					}
					// Si es un objeto, crear una copia plana
					else {
						cleanPayload[key] = { ...value };
					}
				}
			}
			let newPedimentoId = pedimentoId;

			// Determinar si es creación o actualización basándose en si tenemos un ID
			const isCreating = !pedimentoId || data.isCreate;

			if (isCreating) {
				// Crear nuevo pedimento con todos sus sub-recursos
				const response = await pedimentosApi.create(
					cleanPayload as CreatePedimentoData,
					companyStore.activeCompany?.id
				);
				if (response.error) {
					const errorMsg =
						typeof response.error === 'string' ? response.error : 'Error al crear el pedimento';
					throw new Error(errorMsg);
				}
				if (!response.data?.id) throw new Error('No se recibió el ID del pedimento creado');
				newPedimentoId = response.data.id;
			} else {
				// Actualizar pedimento existente con todos sus sub-recursos
				const response = await pedimentosApi.update(
					pedimentoId!,
					cleanPayload as UpdatePedimentoData,
					companyStore.activeCompany?.id
				);
				if (response.error) throw new Error(response.error);

				// Forzar recarga de datos del router (útil si hay navegación con SvelteKit)
				try {
					await invalidateAll();
				} catch (invalidateError) {
					console.error('❌ Error en invalidateAll:', invalidateError);
				}
			}

			toast.success(
				isCreating
					? 'Pedimento creado exitosamente'
					: 'Todos los cambios se guardaron correctamente'
			);

			// Redirigir siempre de vuelta al listado principal una vez guardado correctamente
			await goto('/dashboard/pedimentos');
		} catch (e) {
			if (e instanceof Error) {
				if (e.message.includes('401')) {
					toast.error('Sesión expirada. Recargando página...');
					setTimeout(() => {
						window.location.reload();
					}, 1500);
				} else {
					// Extracción segura del error
					let errorStr = '';
					try {
						if (typeof e.message === 'object') {
							errorStr = JSON.stringify(e.message);
						} else if (e.message === '[object Object]') {
							// Si el mensaje es literalmente [object Object], intentamos ver si e tiene otras props
							errorStr = JSON.stringify(e);
						} else {
							errorStr = e.message || String(e);
						}
					} catch (jsonErr) {
						errorStr = String(e);
					}

					if (
						errorStr.includes('No existe un Tipo de Cambio registrado') ||
						errorStr.includes('financials.exchange_rate')
					) {
						toast.error(
							'No hay tipo de cambio para la fecha seleccionada. Si es una fecha futura, puedes guardar y capturarlo después; si no es futura, registra el tipo de cambio.'
						);
						activeTab = 'general';
						return;
					}

					// Fallback normal: intentar mostrar algo legible
					let displayError = '';
					if (errorStr.includes('Error interno de validación') || errorStr.includes('validation error')) {
						displayError = 'Revisa los datos ingresados. Algunos campos obligatorios podrían estar vacíos o tener un formato incorrecto.';
					} else if (errorStr.includes('{')) {
						// Si parece JSON, intentar formatearlo un poco o mostrar mensaje genérico
						try {
							const errObj = JSON.parse(errorStr);
							// Si es del formato {"field": ["msg"]}
							const values = Object.values(errObj).flat();
							displayError = values.join(', ');
						} catch {
							displayError = 'Error al guardar. Por favor, revisa que todos los campos obligatorios estén completos.';
						}
					} else {
						displayError = errorStr;
					}
					toast.error(displayError);
				}
			} else {
				toast.error('Error al guardar los cambios');
			}
			console.error('Error saving all:', e);
		} finally {
			saving = false;
		}
	}
</script>

{#if !canUsePedimentoEditor}
	<div
		class="flex h-[calc(100svh-4rem)] flex-col p-6 group-has-data-[collapsible=icon]/sidebar-wrapper:h-[calc(100svh-3rem)]"
	>
		<ErrorState status={403} />
	</div>
{:else}
<div class="space-y-6">
	<!-- Header -->
	<div class="flex items-center justify-between">
		<div class="space-y-1">
			<div class="flex items-center gap-3">
				<Button variant="ghost" size="icon" onclick={handleBack}>
					<ArrowLeft size={20} />
				</Button>
				<h1 class="text-3xl font-bold tracking-tight">
					{#if data.isCreate}
						Nuevo Pedimento
					{:else}
						Pedimento #{data.pedimento?.id ?? ''}
					{/if}
				</h1>
				{#if data.isCreate}
					<Badge variant="default">Nuevo</Badge>
				{/if}
				{#if generalFormData?.status || data.pedimento?.status}
					<Badge variant={getStatusColor(generalFormData?.status || data.pedimento?.status)}>
						{generalFormData?.status || data.pedimento?.status}
					</Badge>
				{/if}
				{#if data.pedimento?.pedimento_rectification_origin || otrosDatosFormData?.es_rectificacion === 'si'}
					<Badge variant="outline" class="border-amber-500 bg-amber-50 text-amber-500">R1</Badge>
				{/if}
			</div>
			<p class="text-muted-foreground">
				{#if generalFormData?.year && generalFormData?.customs_office && generalFormData?.license && generalFormData?.pedimento_number}
					Número: {generalFormData.year}-{(generalFormData.customs_office ?? '').toString().slice(0, 2)}-{generalFormData.license}-{generalFormData.pedimento_number}
				{:else if !data.isCreate && data.pedimento?.pedimento_number}
					Número: {data.pedimento?.year ?? ''}-{(data.pedimento?.customs_office ?? '').toString().slice(0, 2)}-{data
						.pedimento?.license ?? ''}-{data.pedimento?.pedimento_number ?? ''}
				{:else}
					Edita los detalles del pedimento
				{/if}
			</p>
		</div>
	</div>

	<Separator />

	<!-- Tabs con footer fijo -->
	<Tabs.Root
		value={activeTab}
		onValueChange={(v) => {
			if (v) activeTab = v;
		}}
		class="space-y-4"
	>
		<!-- Tab content with bottom padding for floating footer -->
		<div id="main-form-content" class="pb-24">
			<Tabs.Content value="general">
				<GeneralTabForm
					bind:this={generalTabInstance}
					pedimento={data.pedimento}
					bind:formData={generalFormData}
					bind:identificadoresFormData
					pedimentoCodes={data.pedimentoCodes}
					customsSections={data.customsSections}
					customsBrokers={data.customsBrokers}
					clients={data.clients}
					codePedimentoRegimens={data.codePedimentoRegimens}
					pedimentoTransportCatalog={data.pedimentoTransportCatalog}
					isActive={activeTab === 'general'}
				/>
			</Tabs.Content>

			<Tabs.Content value="dates">
				<DatesTabForm
					pedimento={data.pedimento}
					bind:formData={observacionesFormData}
					bind:exists={observacionesExists}
					pedimentoType={generalFormData?.pedimento_type || data.pedimento?.pedimento_type || ''}
					pedimentoNumber={generalFormData?.year &&
					generalFormData?.customs_office &&
					generalFormData?.license &&
					generalFormData?.pedimento_number
						? `${generalFormData.year}-${(generalFormData.customs_office ?? '').toString().slice(0, 2)}-${generalFormData.license}-${generalFormData.pedimento_number}`
						: !data.isCreate && data.pedimento?.pedimento_number
							? `${data.pedimento?.year ?? ''}-${(data.pedimento?.customs_office ?? '').toString().slice(0, 2)}-${data.pedimento?.license ?? ''}-${data.pedimento?.pedimento_number ?? ''}`
							: ''}
				/>
			</Tabs.Content>

			<!-- <Tabs.Content value="facturas">
			<FacturasTabForm 
			bind:formData={facturasFormData}
		/>
	</Tabs.Content> -->

			<!-- <!-- <Tabs.Content value="partidas">
		<PartidasTabForm 
			bind:formData={partidasFormData}
		/>
	</Tabs.Content> -->

			<Tabs.Content value="bultos-transportes">
				<BultosTransportesTabForm
					pedimento={data.pedimento}
					bind:formData={bultosTransportesFormData}
				/>
			</Tabs.Content>
			<!-- <Tabs.Content value="descargas">
		<DescargasTabForm 
			bind:formData={descargasFormData}
		/>
	</Tabs.Content> -->
			<Tabs.Content value="contribuciones">
				<ContribucionesTabForm
					bind:formData={contribucionesFormData}
					isActive={activeTab === 'contribuciones'}
				/>
			</Tabs.Content>
			<Tabs.Content value="cuentas-compensacion">
				<CuentasCompensacionTabForm bind:formData={cuentasCompensacionFormData} />
			</Tabs.Content>
			<Tabs.Content value="otros-datos">
				{#key data.pedimento?.id}
					<OtrosDatosTabForm
						pedimento={data.pedimento}
						bind:formData={otrosDatosFormData}
						isActive={activeTab === 'otros-datos'}
					/>
				{/key}
			</Tabs.Content>
			<Tabs.Content value="digitalizacion">
				<DigitalizacionTabForm bind:formData={digitalizacionFormData} />
			</Tabs.Content>
		</div>

		<!-- Footer fijo en la parte inferior -->
		<div
			class="fixed right-0 bottom-0 left-0 z-[5] border-t bg-background/95 shadow-lg backdrop-blur transition-[left] duration-200 ease-linear supports-[backdrop-filter]:bg-background/80"
			style:left={sidebar.isMobile ? '0' : sidebar.open ? 'var(--sidebar-width)' : '0'}
		>
			<div class="mx-auto max-w-[1400px] space-y-4 px-4 py-4">
				<!-- Tabs Navigation -->
				<div class="w-full overflow-x-auto pb-2">
					<Tabs.List class="inline-flex w-full gap-1">
						<Tabs.Trigger value="general" class="flex items-center gap-1.5 px-2.5 py-1.5 text-sm">
							<FileText size={14} />
							<span>General</span>
						</Tabs.Trigger>
						<Tabs.Trigger value="dates" class="flex items-center gap-1.5 px-2.5 py-1.5 text-sm">
							<MessageSquare size={14} />
							<span>Observ.</span>
						</Tabs.Trigger>
						<!-- <Tabs.Trigger value="facturas" class="flex items-center gap-1.5 px-2.5 py-1.5 text-sm">
					<FileSpreadsheet size={14} />
					<span>Facturas</span>
				</Tabs.Trigger> -->
						<!-- <Tabs.Trigger value="partidas" class="flex items-center gap-1.5 px-2.5 py-1.5 text-sm">
					<Package size={14} />
					<span>Partidas</span>
				</Tabs.Trigger> -->
						<Tabs.Trigger
							value="bultos-transportes"
							class="flex items-center gap-1.5 px-2.5 py-1.5 text-sm"
						>
							<Box size={14} />
							<span>Bultos/Trans.</span>
						</Tabs.Trigger>
						<!-- <Tabs.Trigger value="descargas" class="flex items-center gap-1.5 px-2.5 py-1.5 text-sm">
					<Download size={14} />
					<span>Descargas</span>
				</Tabs.Trigger> -->
						<Tabs.Trigger
							value="contribuciones"
							class="flex items-center gap-1.5 px-2.5 py-1.5 text-sm"
						>
							<Coins size={14} />
							<span>Contribuc.</span>
						</Tabs.Trigger>
						<Tabs.Trigger
							value="cuentas-compensacion"
							class="flex items-center gap-1.5 px-2.5 py-1.5 text-sm"
						>
							<Wallet size={14} />
							<span>Cuentas/Comp.</span>
						</Tabs.Trigger>
						<Tabs.Trigger
							value="otros-datos"
							class="flex items-center gap-1.5 px-2.5 py-1.5 text-sm"
						>
							<FileStack size={14} />
							<span>Otros</span>
						</Tabs.Trigger>
						<Tabs.Trigger
							value="digitalizacion"
							class="flex items-center gap-1.5 px-2.5 py-1.5 text-sm"
						>
							<Scan size={14} />
							<span>Digital.</span>
						</Tabs.Trigger>
					</Tabs.List>
				</div>

				<!-- Botones de acción -->
				<div class="flex justify-end gap-3">
					<Button type="button" variant="outline" onclick={handleBack} disabled={saving}>
						Cancelar
					</Button>
					<Button onclick={handleSaveAll} disabled={saving}>
						{#if saving}
							<LoaderCircle class="mr-2 h-4 w-4 animate-spin" />
							Guardando todos los cambios...
						{:else}
							<Save size={16} class="mr-2" />
							Guardar Todos los Cambios
						{/if}
					</Button>
				</div>
			</div>
		</div>
	</Tabs.Root>

	<!-- Modal de prerrequisitos: agentes aduanales y clientes -->
	{#if data.isCreate}
		<PrerequisitesModal
			bind:open={showPrerequisitesModal}
			{agentsCount}
			{clientsCount}
			onAccept={() => (showPrerequisitesModal = false)}
			onCancel={() => goto('/dashboard/pedimentos')}
		/>
	{/if}
</div>
{/if}
