import { AxiosInstance } from "axios";
import { EntityMethods, Entity } from "../../types/entity";

/**
 * Create entity methods for a specific entity type
 * @param client HTTP client
 * @param appId Application ID
 * @param entityName Entity name
 * @returns Entity methods
 */
export function createEntityMethods(
  client: AxiosInstance,
  appId: string | number,
  entityName: string
): EntityMethods {
  const basePath = `/apps/${appId}/entities/${entityName}`;

  return {
    /**
     * List entities with optional sorting, pagination, and field selection
     * @param sort Optional sorting parameter
     * @param limit Optional limit for pagination
     * @param skip Optional skip for pagination
     * @param fields Optional fields to include
     */
    async list(
      sort?: string,
      limit?: number,
      skip?: number,
      fields?: string[] | string
    ): Promise<Entity[]> {
      const params: Record<string, any> = {};

      if (sort) params.sort = sort;
      if (limit) params.limit = limit;
      if (skip) params.skip = skip;
      if (fields)
        params.fields = Array.isArray(fields) ? fields.join(",") : fields;

      return client.get(basePath, { params });
    },

    /**
     * Filter entities by query with optional sorting, pagination, and field selection
     * @param query Filter query
     * @param sort Optional sorting parameter
     * @param limit Optional limit for pagination
     * @param skip Optional skip for pagination
     * @param fields Optional fields to include
     */
    async filter(
      query: any,
      sort?: string,
      limit?: number,
      skip?: number,
      fields?: string[] | string
    ): Promise<Entity[]> {
      const params: Record<string, any> = {
        q: JSON.stringify(query),
      };

      if (sort) params.sort = sort;
      if (limit) params.limit = limit;
      if (skip) params.skip = skip;
      if (fields)
        params.fields = Array.isArray(fields) ? fields.join(",") : fields;

      return client.get(basePath, { params });
    },

    /**
     * Get a single entity by ID
     * @param id Entity ID
     */
    get: async (id: string): Promise<Entity> => {
      return client.get(`${basePath}/${id}`);
    },

    /**
     * Create a new entity
     * @param data Entity data
     */
    create: async (data: Record<string, any>): Promise<Entity> => {
      return client.post(basePath, data);
    },

    /**
     * Update an existing entity
     * @param id Entity ID
     * @param data Updated entity data
     */
    update: async (id: string, data: Record<string, any>): Promise<Entity> => {
      return client.put(`${basePath}/${id}`, data);
    },

    /**
     * Delete an entity
     * @param id Entity ID
     */
    delete: async (id: string): Promise<void> => {
      return client.delete(`${basePath}/${id}`);
    },

    /**
     * Delete multiple entities matching a query
     * @param query Filter query for entities to delete
     */
    deleteMany: async (query: Record<string, any>): Promise<void> => {
      return client.delete(basePath, { data: query });
    },

    /**
     * Create multiple entities in a single operation
     * @param data Array of entity data
     */
    bulkCreate: async (data: Record<string, any>[]): Promise<Entity[]> => {
      return client.post(`${basePath}/bulk`, data);
    },

    /**
     * Import entities from a file
     * @param file File containing entity data
     */
    async importEntities(file: File): Promise<any> {
      const formData = new FormData();
      formData.append("file", file, file.name);

      return client.post(`${basePath}/import`, formData, {
        headers: {
          "Content-Type": "multipart/form-data",
        },
      });
    },
  };
}