import type {Ref} from 'vue'
import {computed, ref} from 'vue'
import type {ReceptionData, ReceptionPayload, WeightEntryData} from '~/services/dto/reception-data'
import type {WeightData} from '~/services/dto/weight-data'
import {getWeight} from '~/services/reception'
import {createWeight, updateWeight} from '~/services/weight'

export type WeighingMode = 'gross' | 'tare'

type UseWeighingOptions = {
    mode: WeighingMode
    reception: Ref<ReceptionData | null>
    updateReception: (id: number, payload: ReceptionPayload) => Promise<ReceptionData | null>
    loadReception?: (id: number) => Promise<ReceptionData | null>
}

export const useWeighing = ({
    mode,
    reception,
    updateReception,
    loadReception
}: UseWeighingOptions) => {
    const weightData = ref<WeightData | null>(null)
    const isFetching = ref(false)

    const currentWeightEntry = computed<WeightEntryData | null>(() => {
        const weights = reception.value?.weights ?? []
        return weights.find((entry) => entry.type === mode) ?? null
    })

    const displayWeight = computed(() => weightData.value?.weight ?? currentWeightEntry.value?.weight ?? null)
    const displayDsd = computed(() => weightData.value?.dsd ?? currentWeightEntry.value?.dsd ?? '-')
    const title = computed(() => (mode === 'gross' ? 'Pesée à plein' : 'Pesée à vide'))
    const showLoadingBox = computed(
        () => isFetching.value || (displayWeight.value === null && currentWeightEntry.value === null)
    )

    const fetchWeight = async () => {
        isFetching.value = true
        weightData.value = await getWeight().finally(() => {
            isFetching.value = false
        })
    }

    const saveWeight = async () => {
        if (!reception.value) {
            return
        }

        const existingEntry = currentWeightEntry.value
        const baseDsd = weightData.value?.dsd ?? existingEntry?.dsd ?? null
        const baseWeight = weightData.value?.weight ?? existingEntry?.weight ?? null
        const baseWeighedAt = weightData.value?.weighedAt ?? existingEntry?.weighedAt ?? null

        if (baseWeight === null) {
            return
        }

        if (existingEntry?.id) {
            await updateWeight(existingEntry.id, {
                type: mode,
                dsd: baseDsd,
                weight: baseWeight,
                weighedAt: baseWeighedAt
            })
        } else {
            await createWeight({
                reception: `api/receptions/${reception.value.id}`,
                type: mode,
                dsd: baseDsd,
                weight: baseWeight,
                weighedAt: baseWeighedAt
            })
        }

        const nextStep = mode === 'tare'
            ? reception.value.currentStep
            : reception.value.currentStep + 1
        await updateReception(reception.value.id, {
            currentStep: nextStep,
            isValid: reception.value.isValid
        })

        if (loadReception) {
            await loadReception(reception.value.id)
        }
    }

    return {
        weightData,
        currentWeightEntry,
        displayWeight,
        displayDsd,
        title,
        showLoadingBox,
        fetchWeight,
        saveWeight
    }
}