mail_manager/src/services/serviceService.ts

/**
 * Service management service
 */

import type {
  ServiceListRequest,
  ServiceListResponse,
  ServiceFetchRequest,
  ServiceFetchResponse,
  ServiceExtantRequest,
  ServiceExtantResponse,
  ServiceCreateResponse,
  ServiceCreateRequest,
  ServiceUpdateResponse,
  ServiceUpdateRequest,
  ServiceDeleteResponse,
  ServiceDeleteRequest,
  ServiceDiscoverRequest,
  ServiceTestRequest,
  ServiceTestResponse,
  ServiceInterface,
  ServiceDiscoverResponse,
} from '../types/service';
import { useIntegrationStore } from '@KTXC/stores/integrationStore';
import { transceivePost, transceiveStream } from './transceive';
import { ServiceObject } from '../models/service';

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

export const serviceService = {

  /**
   * Retrieve list of services, optionally filtered by source selector
   * 
   * @param request - list request parameters
   * 
   * @returns Promise with service object list grouped by provider and keyed by service identifier
   */
  async list(request: ServiceListRequest = {}): Promise<Record<string, Record<string, ServiceObject>>> {
    const response = await transceivePost<ServiceListRequest, ServiceListResponse>('service.list', request);
    
    // Convert nested response to ServiceObject instances
    const providerList: Record<string, Record<string, ServiceObject>> = {};
    Object.entries(response).forEach(([providerId, providerServices]) => {
      const serviceList: Record<string, ServiceObject> = {};
      Object.entries(providerServices).forEach(([serviceId, serviceData]) => {
        serviceList[serviceId] = createServiceObject(serviceData);
      });
      providerList[providerId] = serviceList;
    });
    
    return providerList;
  },

  /**
   * Retrieve a specific service by provider and identifier
   * 
   * @param request - fetch request parameters
   * 
   * @returns Promise with service object
   */
  async fetch(request: ServiceFetchRequest): Promise<ServiceObject> {
    const response = await transceivePost<ServiceFetchRequest, ServiceFetchResponse>('service.fetch', request);
    return createServiceObject(response);
  },

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

  /**
   * Discover services, streaming results as each provider responds
   * 
   * @param request   - discover request parameters
   * @param onService - called for each discovered service as it arrives
   * 
   * @returns Promise resolving to { total } when the stream completes
   */
  async discover(
    request: ServiceDiscoverRequest,
    onService: (service: ServiceObject) => void
  ): Promise<{ total: number }> {
    return await transceiveStream<ServiceDiscoverRequest, ServiceDiscoverResponse>(
      'service.discover',
      request,
      (service) => {
        const serviceData: ServiceInterface = {
          '@type': 'mail:service',
          provider: service.provider,
          identifier: null,
          label: null,
          enabled: false,
          location: service.location,
        };
        onService(createServiceObject(serviceData));
      }
    );
  },

  /**
   * Test service connectivity and configuration
   * 
   * @param request - Service test request
   * @returns Promise with test results
   */
  async test(request: ServiceTestRequest): Promise<ServiceTestResponse> {
    return await transceivePost<ServiceTestRequest, ServiceTestResponse>('service.test', request);
  },

  /**
   * Create a new service
   * 
   * @param request - create request parameters
   * 
   * @returns Promise with created service object
   */
  async create(request: ServiceCreateRequest): Promise<ServiceObject> {
    const response = await transceivePost<ServiceCreateRequest, ServiceCreateResponse>('service.create', request);
    return createServiceObject(response);
  },

  /**
   * Update a existing service
   * 
   * @param request - update request parameters
   * 
   * @returns Promise with updated service object
   */
  async update(request: ServiceUpdateRequest): Promise<ServiceObject> {
    const response = await transceivePost<ServiceUpdateRequest, ServiceUpdateResponse>('service.update', request);
    return createServiceObject(response);
  },

  /**
   * Delete a service
   * 
   * @param request - delete request parameters
   * 
   * @returns Promise with deletion result
   */
  async delete(request: { provider: string; identifier: string | number }): Promise<any> {
    return await transceivePost<ServiceDeleteRequest, ServiceDeleteResponse>('service.delete', request);
  },
};

export default serviceService;