src/services/assetItemApi.ts

import apiClient from '@/lib/api/axios-instance';
import { AxiosError } from 'axios';
import {
  AssetItem,
  AssetItemCreateRequest,
  AssetItemUpdateRequest,
} from '@/types/asset-management';

// Helper to handle API errors with user-friendly messages
const handleApiError = (error: unknown, operation: string): never => {
  console.error(`AssetItemApi: Error during ${operation}:`, error);

  if (error instanceof AxiosError) {
    const status = error.response?.status;
    const message = error.response?.data?.message || error.message;

    switch (status) {
      case 400:
        throw new Error(`Invalid request: ${message}`);
      case 401:
        throw new Error('You are not authorized to perform this action. Please log in again.');
      case 403:
        throw new Error('You do not have permission to perform this action.');
      case 404:
        throw new Error('The requested item was not found.');
      case 409:
        throw new Error('This item already exists or conflicts with existing data.');
      case 422:
        throw new Error(`Validation failed: ${message}`);
      case 500:
        throw new Error('Server error occurred. Please try again later.');
      case 503:
        throw new Error('Service is temporarily unavailable. Please try again later.');
      default:
        throw new Error(`${operation} failed: ${message}`);
    }
  }

  throw new Error(`${operation} failed: ${error instanceof Error ? error.message : 'Unknown error'}`);
};

/**
 * Asset Item API Service
 */
export const assetItemApi = {
  /**
   * Get all items for a specific asset
   */
  getByAsset: async (assetId: number): Promise<AssetItem[]> => {
    try {
      const response = await apiClient.get<AssetItem[]>(`/assets/${assetId}/items`);
      return response.data || [];
    } catch (error) {
      handleApiError(error, 'Fetching asset items');
    }
  },

  /**
   * Get a single asset item by ID
   */
  getById: async (itemId: number): Promise<AssetItem> => {
    try {
      const response = await apiClient.get<AssetItem>(`/api/AssetItem/${itemId}`);
      if (!response.data) {
        throw new Error('Item not found');
      }
      return response.data;
    } catch (error) {
      handleApiError(error, 'Fetching asset item');
    }
  },

  /**
   * Create a new asset item
   */
  create: async (item: AssetItemCreateRequest): Promise<AssetItem> => {
    try {
      const response = await apiClient.post<AssetItem>('/api/AssetItem', item);
      if (!response.data) {
        throw new Error('Failed to create item');
      }
      return response.data;
    } catch (error) {
      handleApiError(error, 'Creating asset item');
    }
  },

  /**
   * Update an existing asset item
   */
  update: async (itemId: number, item: AssetItemUpdateRequest): Promise<AssetItem> => {
    try {
      const response = await apiClient.put<AssetItem>(`/api/AssetItem/${itemId}`, item);
      if (!response.data) {
        throw new Error('Failed to update item');
      }
      return response.data;
    } catch (error) {
      handleApiError(error, 'Updating asset item');
    }
  },

  /**
   * Delete an asset item
   */
  delete: async (itemId: number): Promise<void> => {
    try {
      await apiClient.delete(`/api/AssetItem/${itemId}`);
    } catch (error) {
      handleApiError(error, 'Deleting asset item');
    }
  },
};

export default assetItemApi;