import { beforeEach, describe, expect, it, vi } from 'vitest'
import { http } from '@/shared/api/http'
import { cancelDispatch, createDispatchDraftContainer, deleteDispatchDraftContainer, getDispatch, getDispatchBolPdf, getDispatchExternalFreight, getDispatchFeeCoverage, listDispatchCandidates, listDispatchDrafts, listDispatches, lockDispatchDraftPallet, preArrangeDispatch, releaseDispatchDraft, transferDispatchToDelivery, unlockDispatchDraftPallet, updateDispatch } from './dispatches'

vi.mock('@/shared/api/http', async (importOriginal) => ({ ...(await importOriginal<typeof import('@/shared/api/http')>()), http: { get: vi.fn(), post: vi.fn(), put: vi.fn(), delete: vi.fn() } }))

describe('dispatch overseas API', () => {
  it('locks and submits actual return receipts without pretending they are plan pallets', async () => {
    vi.mocked(http.post).mockResolvedValue({ code: '200', data: null })
    await lockDispatchDraftPallet('RETURN:190000000000000099', 'draft-return', 'container-1')
    expect(http.post).toHaveBeenLastCalledWith('/platform/v1/last-leg/dispatches/draft-locks/lock', {
      sourceType: 'RETURN_RECEIPT', returnReceiptId: '190000000000000099', draftToken: 'draft-return', draftContainerId: 'container-1',
    })
    await unlockDispatchDraftPallet('RETURN:190000000000000099', 'draft-return')
    expect(http.post).toHaveBeenLastCalledWith('/platform/v1/last-leg/dispatches/draft-locks/unlock', {
      sourceType: 'RETURN_RECEIPT', returnReceiptId: '190000000000000099', draftToken: 'draft-return',
    })
    await preArrangeDispatch({ planPalletIds: [], returnReceiptIds: ['190000000000000099'], draftToken: 'draft-return' })
    expect(http.post).toHaveBeenLastCalledWith('/platform/v1/last-leg/dispatches/pre-arrange', {
      planPalletIds: [], returnReceiptIds: ['190000000000000099'], draftToken: 'draft-return',
    })
  })
  it('reads external freight from the scoped dispatch without a supplied customer', async () => {
    vi.mocked(http.get).mockResolvedValue({ code: '200', data: { snapshotHash: 'hash', requiresDeliveryFee: false, quotes: [] } })
    expect(await getDispatchExternalFreight('DP/1')).toEqual({ snapshotHash: 'hash', requiresDeliveryFee: false, quotes: [] })
    expect(http.get).toHaveBeenCalledWith('/platform/v1/last-leg/dispatches/DP%2F1/external-freight')
  })
  it('loads per-shipment coverage without exposing a caller-supplied customer or losing long IDs', async () => {
    vi.mocked(http.get).mockResolvedValue({ code: '200', data: { dispatchNo: 'DP/1', sourceComplete: true, blockReason: null, cargoHash: 'hash', cargo: [], feeSources: [{ financeFeeId: '190000000000000099', sourceFeeId: '190000000000000100', customerId: '101', sourceInboundId: '11', sourceVersion: '2', amount: '100.25' }] } })
    const result = await getDispatchFeeCoverage('DP/1')
    expect(http.get).toHaveBeenCalledWith('/platform/v1/last-leg/dispatches/DP%2F1/fee-coverage')
    expect(result.feeSources[0]).toMatchObject({ financeFeeId: '190000000000000099', sourceVersion: 2, amount: 100.25 })
  })
  beforeEach(() => {
    vi.mocked(http.get).mockReset()
    vi.mocked(http.post).mockReset()
    vi.mocked(http.put).mockReset()
    vi.mocked(http.delete).mockReset()
  })

  it('uses the platform dispatch page without customer scope', async () => {
    vi.mocked(http.get).mockResolvedValue({
      code: '200', message: 'success', data: { records: [], page: 2, size: 50, total: 0, pages: 0 },
    })

    await listDispatches({
      page: 2, size: 50, dispatchNo: 'PC-1',
      vehiclePlate: 'CA-100', status: 'PENDING_DEPARTURE', fbaAppointmentNo: 'FBA-1',
    })

    expect(http.get).toHaveBeenCalledWith('/platform/v1/last-leg/dispatches', {
      params: {
        page: 2, size: 50, dispatchNo: 'PC-1',
        vehiclePlate: 'CA-100', status: 'PENDING_DEPARTURE', fbaAppointmentNo: 'FBA-1',
      },
    })
  })

  it('loads a platform dispatch detail by encoded dispatch number', async () => {
    vi.mocked(http.get).mockResolvedValue({ code: '200', message: 'success', data: { id: '1', dispatchNo: 'PC/1' } })

    await getDispatch('PC/1')

    expect(http.get).toHaveBeenCalledWith('/platform/v1/last-leg/dispatches/PC%2F1')
  })

  it('requests the generated BOL as a PDF blob', async () => {
    vi.mocked(http.get).mockResolvedValue(new Blob(['%PDF-test']))
    await getDispatchBolPdf('PC/1')
    expect(http.get).toHaveBeenCalledWith('/platform/v1/last-leg/dispatches/PC%2F1/prints/bol', { responseType: 'blob' })
  })

  it('loads candidates and creates a pre-arrange dispatch in an explicit customer scope', async () => {
    vi.mocked(http.get).mockResolvedValue({ code: '200', message: 'success', data: [] })
    vi.mocked(http.post).mockResolvedValue({ code: '200', message: 'success', data: { id: '1', dispatchNo: 'PC-1' } })
    await listDispatchCandidates({ planIds: '101,102', fbaWarehouseCode: 'ONT8', sourceStage: 'PLAN' })
    await preArrangeDispatch({ planPalletIds: ['190000000000000099'] })
    expect(http.get).toHaveBeenCalledWith('/platform/v1/last-leg/dispatches/candidates', { params: { planIds: '101,102', fbaWarehouseCode: 'ONT8', sourceStage: 'PLAN' } })
    expect(http.post).toHaveBeenCalledWith('/platform/v1/last-leg/dispatches/pre-arrange', { planPalletIds: ['190000000000000099'] })
  })

  it('loads platform candidates without selected inbound plans', async () => {
    vi.mocked(http.get).mockResolvedValue({ code: '200', message: 'success', data: [] })

    await listDispatchCandidates({ sourceStage: 'RECEIVED' })

    expect(http.get).toHaveBeenCalledWith('/platform/v1/last-leg/dispatches/candidates', {
      params: { sourceStage: 'RECEIVED' },
    })
  })

  it('locks, unlocks, and releases intelligent dispatch drafts through dedicated endpoints', async () => {
    vi.mocked(http.post).mockResolvedValue({ code: '200', message: 'success', data: null })

    await lockDispatchDraftPallet('99', 'draft-1')
    await unlockDispatchDraftPallet('99', 'draft-1')
    await releaseDispatchDraft('draft-1')

    expect(http.post).toHaveBeenNthCalledWith(1, '/platform/v1/last-leg/dispatches/draft-locks/lock', { planPalletId: '99', draftToken: 'draft-1' })
    expect(http.post).toHaveBeenNthCalledWith(2, '/platform/v1/last-leg/dispatches/draft-locks/unlock', { planPalletId: '99', draftToken: 'draft-1' })
    expect(http.post).toHaveBeenNthCalledWith(3, '/platform/v1/last-leg/dispatches/draft-locks/release', { draftToken: 'draft-1' })
  })

  it('edits and cancels only by dispatchNo without customer scope or status mutation', async () => {
    vi.mocked(http.put).mockResolvedValue({ code: '200', message: 'success', data: { id: '1', dispatchNo: 'PC/1' } })
    vi.mocked(http.delete).mockResolvedValue({ code: '200', message: 'success', data: null })
    await updateDispatch('PC/1', { vehiclePlate: 'CA-100' })
    await cancelDispatch('PC/1')
    expect(http.put).toHaveBeenCalledWith('/platform/v1/last-leg/dispatches/PC%2F1', { vehiclePlate: 'CA-100' })
    expect(http.put).not.toHaveBeenCalledWith(expect.anything(), expect.objectContaining({ status: expect.anything() }))
    expect(http.delete).toHaveBeenCalledWith('/platform/v1/last-leg/dispatches/PC%2F1')
  })

  it('transfers to delivery only by dispatchNo without customerId', async () => {
    vi.mocked(http.post).mockResolvedValue({ code: '200', message: 'success', data: { dispatchNo: 'PC/1', outboundNo: 'OUT-1', outboundStatus: 'PICKED', palletCount: 2, packageCount: 20, deliveries: [{ deliveryNo: 'DEL-1', deliveryStatus: 'WAIT_DELIVERY', destinationWarehouseCode: 'ACY2', palletCount: 2, packageCount: 20 }], replayed: false } })
    const payload = { idempotencyKey: 'transfer-1', plannedDeliveryAt: '2026-09-01T10:00:00', deliveryMethod: 'TRUCK_PALLET', pickupMethod: 'WAREHOUSE_PICKUP', loadingType: 'PALLET', fees: [{ feeType: 'DELIVERY_FEE', feeName: '派送费用', direction: 'RECEIVABLE' as const, currency: 'USD' as const, amount: 10 }] }
    await transferDispatchToDelivery('PC/1', payload)
    expect(http.post).toHaveBeenCalledWith('/platform/v1/last-leg/dispatches/PC%2F1/transfer-delivery', payload)
  })

  it('loads drafts and preserves long container ids in create and delete paths', async () => {
    vi.mocked(http.get).mockResolvedValue({ code: '200', message: 'success', data: [] })
    vi.mocked(http.post).mockResolvedValue({ code: '200', message: 'success', data: { id: '190000000000000099', capacity: 30, palletIds: [] } })
    vi.mocked(http.delete).mockResolvedValue({ code: '200', message: 'success', data: null })

    await listDispatchDrafts()
    await createDispatchDraftContainer('draft/1', 30)
    await deleteDispatchDraftContainer('draft/1', '190000000000000099')

    expect(http.get).toHaveBeenCalledWith('/platform/v1/last-leg/dispatches/drafts')
    expect(http.post).toHaveBeenCalledWith('/platform/v1/last-leg/dispatches/drafts/containers', { draftToken: 'draft/1', capacity: 30 })
    expect(http.delete).toHaveBeenCalledWith('/platform/v1/last-leg/dispatches/drafts/draft%2F1/containers/190000000000000099')
  })
})