/**
 * Entity management service
 */

import { transceivePost } from './transceive';
import type {
  EntityListRequest,
  EntityListResponse,
  EntityFetchRequest,
  EntityFetchResponse,
  EntityExtantRequest,
  EntityExtantResponse,
  EntityCreateRequest,
  EntityCreateResponse,
  EntityUpdateRequest,
  EntityUpdateResponse,
  EntityDeleteRequest,
  EntityDeleteResponse,
  EntityDeltaRequest,
  EntityDeltaResponse,
  EntityReadRequest,
  EntityReadResponse,
  EntityWriteRequest,
  EntityWriteResponse,
  EntityInterface,
} from '../types/entity';
import { useIntegrationStore } from '@KTXC/stores/integrationStore';
import { EntityObject } from '../models';

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

export const entityService = {

  /**
   * Retrieve list of entities, optionally filtered by source selector
   * 
   * @param request - list request parameters
   * 
   * @returns Promise with entity object list grouped by provider, service, collection, and entity identifier
   */
  async list(request: EntityListRequest = {}): Promise<Record<string, Record<string, Record<string, Record<string, EntityObject>>>>> {
    const response = await transceivePost<EntityListRequest, EntityListResponse>('entity.list', request);
    
    // Convert nested response to EntityObject instances
    const providerList: Record<string, Record<string, Record<string, Record<string, EntityObject>>>> = {};
    Object.entries(response).forEach(([providerId, providerServices]) => {
      const serviceList: Record<string, Record<string, Record<string, EntityObject>>> = {};
      Object.entries(providerServices).forEach(([serviceId, serviceCollections]) => {
        const collectionList: Record<string, Record<string, EntityObject>> = {};
        Object.entries(serviceCollections).forEach(([collectionId, collectionEntities]) => {
          const entityList: Record<string, EntityObject> = {};
          Object.entries(collectionEntities).forEach(([entityId, entityData]) => {
            entityList[entityId] = createEntityObject(entityData);
          });
          collectionList[collectionId] = entityList;
        });
        serviceList[serviceId] = collectionList;
      });
      providerList[providerId] = serviceList;
    });
    
    return providerList;
  },

  /**
   * Retrieve a specific entity by provider and identifier
   * 
   * @param request - fetch request parameters
   * 
   * @returns Promise with entity objects keyed by identifier
   */
  async fetch(request: EntityFetchRequest): Promise<Record<string, EntityObject>> {
    const response = await transceivePost<EntityFetchRequest, EntityFetchResponse>('entity.fetch', request);
    
    // Convert response to EntityObject instances
    const list: Record<string, EntityObject> = {};
    Object.entries(response).forEach(([identifier, entityData]) => {
      list[identifier] = createEntityObject(entityData);
    });
    
    return list;
  },

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

  /**
   * Create a new entity
   * 
   * @param request - create request parameters
   * 
   * @returns Promise with created entity object
   */
  async create(request: EntityCreateRequest): Promise<EntityObject> {
    const response = await transceivePost<EntityCreateRequest, EntityCreateResponse>('entity.create', request);
    return createEntityObject(response);
  },

  /**
   * Update an existing entity
   * 
   * @param request - update request parameters
   * 
   * @returns Promise with updated entity object
   */
  async update(request: EntityUpdateRequest): Promise<EntityObject> {
    const response = await transceivePost<EntityUpdateRequest, EntityUpdateResponse>('entity.update', request);
    return createEntityObject(response);
  },

  /**
   * Delete an entity
   * 
   * @param request - delete request parameters
   * 
   * @returns Promise with deletion result
   */
  async delete(request: EntityDeleteRequest): Promise<EntityDeleteResponse> {
    return await transceivePost<EntityDeleteRequest, EntityDeleteResponse>('entity.delete', request);
  },

  /**
   * Retrieve delta changes for entities
   * 
   * @param request - delta request parameters
   * 
   * @returns Promise with delta changes (created, modified, deleted)
   */
  async delta(request: EntityDeltaRequest): Promise<EntityDeltaResponse> {
    return await transceivePost<EntityDeltaRequest, EntityDeltaResponse>('entity.delta', request);
  },

  /**
   * Read entity content
   * 
   * @param request - read request parameters
   * @returns Promise with base64 encoded content
   */
  async read(request: EntityReadRequest): Promise<EntityReadResponse> {
    return await transceivePost<EntityReadRequest, EntityReadResponse>('entity.read', request);
  },

  /**
   * Write content to an entity
   * 
   * @param request - write request parameters
   * @returns Promise with write result
   */
  async write(request: EntityWriteRequest): Promise<EntityWriteResponse> {
    return await transceivePost<EntityWriteRequest, EntityWriteResponse>('entity.write', {
      ...request,
      encoding: request.encoding ?? 'base64',
    });
  },
};

export default entityService;