export interface NormalizeInventoryScopeInputParams {
  department_id?: unknown
  department_ids?: unknown
  departmentIds?: unknown
  asset_type_id?: unknown
  asset_type_ids?: unknown
  assetTypeIds?: unknown
  storage_location_id?: unknown
  storage_location_ids?: unknown
  storageLocationIds?: unknown
}

export interface NormalizedInventoryScopeInput {
  departmentIds: number[]
  assetTypeIds: number[]
  storageLocationIds: number[]
}

const toNormalizedScopeIds = (values: unknown[]) =>
  Array.from(
    new Set(
      values
        .map((value) => Number(value))
        .filter((value) => Number.isInteger(value) && value > 0)
    )
  )

const normalizeScopeIdArray = (primary: unknown, fallback?: unknown) => {
  const mergedValues: unknown[] = []

  if (Array.isArray(primary)) {
    mergedValues.push(...primary)
  } else if (primary !== undefined) {
    mergedValues.push(primary)
  }

  if (Array.isArray(fallback)) {
    mergedValues.push(...fallback)
  } else if (fallback !== undefined) {
    mergedValues.push(fallback)
  }

  return toNormalizedScopeIds(mergedValues)
}

export const normalizeInventoryScopeInput = (
  input: NormalizeInventoryScopeInputParams
): NormalizedInventoryScopeInput => ({
  departmentIds: normalizeScopeIdArray(input.departmentIds ?? input.department_ids, input.department_id),
  assetTypeIds: normalizeScopeIdArray(input.assetTypeIds ?? input.asset_type_ids, input.asset_type_id),
  storageLocationIds: normalizeScopeIdArray(
    input.storageLocationIds ?? input.storage_location_ids,
    input.storage_location_id
  )
})

export const resolveUniqueActiveBorrowRecord = <T extends { person?: { status?: string | null } | null }>(
  records: T[]
) => {
  if (records.length !== 1) {
    return null
  }

  const [record] = records
  if (!record?.person || record.person.status !== 'active') {
    return null
  }

  return record
}