mail_manager/src/services/serviceService.ts

/**
 * Service management service
 */

import type {
  ServiceListRequest,
  ServiceListResponse,
  ServiceExtantRequest,
  ServiceExtantResponse,
  ServiceFetchRequest,
  ServiceFetchResponse,
  ServiceDiscoverRequest,
  ServiceDiscoverResponse,
  ServiceTestRequest,
  ServiceTestResponse,
  ServiceInterface,
  ServiceCreateResponse,
  ServiceCreateRequest,
  ServiceUpdateResponse,
  ServiceUpdateRequest,
  ServiceDeleteResponse,
  ServiceDeleteRequest,
} from '../types/service';
import { useIntegrationStore } from '@KTXC/stores/integrationStore';
import { transceivePost } 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);
  },

  /**
   * Retrieve discoverable services for a given source selector, sorted by provider
   * 
   * @param request - discover request parameters
   * 
   * @returns Promise with array of discovered services sorted by provider
   */
  async discover(request: ServiceDiscoverRequest): Promise<ServiceObject[]> {
    const response = await transceivePost<ServiceDiscoverRequest, ServiceDiscoverResponse>('service.discover', request);
    
    // Convert discovery results to ServiceObjects
    const services: ServiceObject[] = [];
    Object.entries(response).forEach(([providerId, location]) => {
      const serviceData: ServiceInterface = {
        '@type': 'mail:service',
        provider: providerId,
        identifier: null,
        label: null,
        enabled: false,
        location: location,
      };
      services.push(createServiceObject(serviceData));
    });
    
    // Sort by provider
    return services.sort((a, b) => a.provider.localeCompare(b.provider));
  },

  /**
   * 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;