Ferme/frontend/composables/useLiotHandling.ts

import type { Ref } from 'vue'
import type { CarrierData } from '~/services/dto/carrier-data'
import type { DriverData } from '~/services/dto/driver-data'
import type { VehicleData } from '~/services/dto/vehicle-data'
import { getDriverList } from '~/services/driver'
import { getVehicleList } from '~/services/vehicle'
import { SUPPLIER_CODE } from '~/utils/constants'

interface LiotForm {
    carrierId: string
    truckId: string
    driverId: string
    vehicleId: string
    licensePlate: string
}

export const useLiotHandling = (
    form: LiotForm,
    carriers: Ref<CarrierData[]>,
    isHydrating: Ref<boolean>
) => {
    const drivers = ref<DriverData[]>([])
    const vehicles = ref<VehicleData[]>([])
    const isLoadingDrivers = ref(false)
    const isLoadingVehicles = ref(false)
    const allowAnyLicensePlate = ref(false)

    const selectedCarrier = computed(() =>
        carriers.value.find((carrier) => String(carrier.id) === form.carrierId) ?? null
    )

    const isLiotCarrier = computed(() => selectedCarrier.value?.code === SUPPLIER_CODE.LIOT)

    const filteredDrivers = computed<DriverData[]>(() => {
        if (!form.carrierId) return []
        return drivers.value.filter((driver) => String(driver.carrier?.id) === form.carrierId)
    })

    const filteredVehicles = computed<VehicleData[]>(() => {
        if (!form.carrierId) return []
        return vehicles.value.filter(
            (vehicle) =>
                String(vehicle.carrier?.id) === form.carrierId &&
                (!form.truckId || String(vehicle.truck?.id) === form.truckId)
        )
    })

    const loadDrivers = async () => {
        isLoadingDrivers.value = true
        try {
            drivers.value = await getDriverList()
        } finally {
            isLoadingDrivers.value = false
        }
    }

    const loadVehicles = async () => {
        isLoadingVehicles.value = true
        try {
            vehicles.value = await getVehicleList()
        } finally {
            isLoadingVehicles.value = false
        }
    }

    // Auto-select driver/vehicle when carrier changes
    watch(
        () => form.carrierId,
        () => {
            if (isHydrating.value) return
            if (!form.carrierId) {
                form.driverId = ''
                form.vehicleId = ''
                return
            }
            if (!isLiotCarrier.value) {
                form.driverId = ''
                form.vehicleId = ''
                return
            }
            if (filteredDrivers.value.length === 1) {
                form.driverId = String(filteredDrivers.value[0].id)
            }
            if (filteredVehicles.value.length === 1) {
                form.vehicleId = String(filteredVehicles.value[0].id)
            }
        },
        { immediate: true }
    )

    // Validate/auto-select vehicle when truck/carrier changes
    watch(
        () => [form.truckId, form.carrierId, vehicles.value],
        () => {
            if (!isLiotCarrier.value) return
            if (filteredVehicles.value.length === 1) {
                form.vehicleId = String(filteredVehicles.value[0].id)
                return
            }
            if (!form.vehicleId) return
            const matches = filteredVehicles.value.some(
                (vehicle) => String(vehicle.id) === form.vehicleId
            )
            if (!matches) {
                form.vehicleId = ''
            }
        },
        { immediate: true }
    )

    // Sync license plate from selected vehicle
    watch(
        () => [form.vehicleId, form.carrierId, vehicles.value],
        () => {
            if (!isLiotCarrier.value) return
            if (isHydrating.value) return
            const selected = filteredVehicles.value.find(
                (vehicle) => String(vehicle.id) === form.vehicleId
            )
            if (selected) {
                form.licensePlate = selected.plate
                allowAnyLicensePlate.value = false
            }
        }
    )

    // Auto-select vehicle from license plate
    watch(
        () => [form.licensePlate, form.carrierId, vehicles.value],
        () => {
            if (!isLiotCarrier.value || form.vehicleId) return
            const match = filteredVehicles.value.find(
                (vehicle) => vehicle.plate === form.licensePlate
            )
            if (match) {
                form.vehicleId = String(match.id)
            }
        }
    )

    return {
        drivers,
        vehicles,
        isLoadingDrivers,
        isLoadingVehicles,
        allowAnyLicensePlate,
        isLiotCarrier,
        filteredDrivers,
        filteredVehicles,
        loadDrivers,
        loadVehicles
    }
}