/**
 * Provider management service
 */

import type {
  ProviderListRequest,
  ProviderListResponse,
  ProviderExtantRequest,
  ProviderExtantResponse,
  ProviderFetchRequest,
  ProviderFetchResponse,
  ProviderInterface,
} from '../types/provider';
import { useIntegrationStore } from '@KTXC/stores/integrationStore';
import { transceivePost } from './transceive';
import { ProviderObject } from '../models/provider';

/**
 * Helper to create the right provider model class based on provider identifier
 * Uses provider-specific factory if available, otherwise returns base ProviderObject
 */
function createProviderObject(data: ProviderInterface): ProviderObject {
  const integrationStore = useIntegrationStore();
  const factoryItem = integrationStore.getItemById('documents_provider_factory', data.identifier) as any;
  const factory = factoryItem?.factory;
  
  // Use provider factory if available, otherwise base class
  return factory ? factory(data) : new ProviderObject().fromJson(data);
}

export const providerService = {

  /**
   * Retrieve list of providers, optionally filtered by source selector
   * 
   * @param request - list request parameters
   * 
   * @returns Promise with provider object list keyed by provider identifier
   */
  async list(request: ProviderListRequest = {}): Promise<Record<string, ProviderObject>> {
    const response = await transceivePost<ProviderListRequest, ProviderListResponse>('provider.list', request);
    
    // Convert response to ProviderObject instances
    const list: Record<string, ProviderObject> = {};
    Object.entries(response).forEach(([providerId, providerData]) => {
      list[providerId] = createProviderObject(providerData);
    });
    
    return list;
  },

  /**
   * Retrieve specific provider by identifier
   * 
   * @param request - fetch request parameters
   * 
   * @returns Promise with provider object
   */
  async fetch(request: ProviderFetchRequest): Promise<ProviderObject> {
    const response = await transceivePost<ProviderFetchRequest, ProviderFetchResponse>('provider.fetch', request);
    return createProviderObject(response);
  },

  /**
   * Retrieve provider availability status for a given source selector
   * 
   * @param request - extant request parameters
   * 
   * @returns Promise with provider availability status
   */
  async extant(request: ProviderExtantRequest): Promise<ProviderExtantResponse> {
    return await transceivePost<ProviderExtantRequest, ProviderExtantResponse>('provider.extant', request);
  },
};

export default providerService;