mail_manager/src/services/collectionService.ts

/**
 * Collection management service
 */

import { transceivePost } from './transceive';
import type {
  CollectionListRequest,
  CollectionListResponse,
  CollectionExtantRequest,
  CollectionExtantResponse,
  CollectionFetchRequest,
  CollectionFetchResponse,
  CollectionCreateRequest,
  CollectionCreateResponse,
  CollectionUpdateResponse,
  CollectionUpdateRequest,
  CollectionDeleteResponse,
  CollectionDeleteRequest,
  CollectionInterface,
  CollectionMoveRequest,
  CollectionMoveResponse,
} from '../types/collection';
import { useIntegrationStore } from '@KTXC/stores/integrationStore';
import { CollectionObject, CollectionPropertiesObject } from '../models/collection';

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

export const collectionService = {

  /**
   * Retrieve list of collections, optionally filtered by source selector
   * 
   * @param request - list request parameters
   * 
   * @returns Promise with collection object list grouped by provider, service, and collection identifier
   */
  async list(request: CollectionListRequest = {}): Promise<Record<string, Record<string, Record<string, CollectionObject>>>> {
    const response = await transceivePost<CollectionListRequest, CollectionListResponse>('collection.list', request);
    
    // Convert nested response to CollectionObject instances
    const providerList: Record<string, Record<string, Record<string, CollectionObject>>> = {};
    Object.entries(response).forEach(([providerId, providerServices]) => {
      const serviceList: Record<string, Record<string, CollectionObject>> = {};
      Object.entries(providerServices).forEach(([serviceId, serviceCollections]) => {
        const collectionList: Record<string, CollectionObject> = {};
        Object.entries(serviceCollections).forEach(([collectionId, collectionData]) => {
          collectionList[collectionId] = createCollectionObject(collectionData);
        });
        serviceList[serviceId] = collectionList;
      });
      providerList[providerId] = serviceList;
    });
    
    return providerList;
  },

  /**
   * Retrieve a specific collection by provider and identifier
   * 
   * @param request - fetch request parameters
   * 
   * @returns Promise with collection object
   */
  async fetch(request: CollectionFetchRequest): Promise<Record<string, CollectionObject>> {
    const response = await transceivePost<CollectionFetchRequest, CollectionFetchResponse>('collection.fetch', request);
    
    // Convert response to CollectionObject instances
    const list: Record<string, CollectionObject> = {};
    Object.entries(response).forEach(([identifier, entity]) => {
      list[entity.identifier] = createCollectionObject(entity);
    });

    return list;
  },

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

  /**
   * Create a new collection
   * 
   * @param request - create request parameters
   * 
   * @returns Promise with created collection object
   */
  async create(request: CollectionCreateRequest): Promise<CollectionObject> {
    if (request.properties instanceof CollectionPropertiesObject) {
      request.properties = request.properties.toJson();
    }
    const response = await transceivePost<CollectionCreateRequest, CollectionCreateResponse>('collection.create', request);
    return createCollectionObject(response);
  },

  /**
   * Update an existing collection
   * 
   * @param request - update request parameters
   * 
   * @returns Promise with updated collection object
   */
  async update(request: CollectionUpdateRequest): Promise<CollectionObject> {
    if (request.properties instanceof CollectionPropertiesObject) {
      request.properties = request.properties.toJson();
    }
    const response = await transceivePost<CollectionUpdateRequest, CollectionUpdateResponse>('collection.update', request);
    return createCollectionObject(response);
  },

  /**
   * Delete a collection
   * 
   * @param request - delete request parameters
   * 
   * @returns Promise with deletion result
   */
  async delete(request: CollectionDeleteRequest): Promise<boolean | CollectionObject> {
    const response = await transceivePost<CollectionDeleteRequest, CollectionDeleteResponse>('collection.delete', request);

    if (response.disposition === 'moved' && response.mutation) {
      return createCollectionObject(response.mutation);
    }

    return true;
  },

  /**
   * Move a collection to a new target collection
   * 
   * @param request - move request parameters
   * 
   * @returns Promise with moved collection object
   */
  async move(request: CollectionMoveRequest): Promise<CollectionObject> {
    const response = await transceivePost<CollectionMoveRequest, CollectionMoveResponse>('collection.move', request);
    return createCollectionObject(response);
  }
};

export default collectionService;