import ApiClient from './ApiClient';
import { mapConnectorResponse } from './ConnectorClient';
import * as C from './types/Connection';
import * as P from './types/Paginated';
import urls from './urls';

export const mapConnectionResponse = (
  c: C.ConnectionResponse,
): C.Connection => ({
  name: c.name,
  id: c.id,
  connector: mapConnectorResponse(c.connector),
  settings: c.settings,
});

export const mapCreateConnectionResponse = (
  c: C.CreateConnectionResponse,
): C.CreateConnectionServer => ({
  id: c.id,
  name: c.name,
  settings: c.settings,
});

export default class ConnectionClient {
  async getConnections(
    this: ApiClient,
    params: C.GetConnectionsQuery = {},
  ): Promise<P.Paginated<C.Connection>> {
    const sortByMap = {
      createdAt: 'created_at',
      updatedAt: 'updated_at',
    } as const;

    const data = await this.requestProtected<void, C.ConnectionsResponse>({
      method: 'GET',
      url: urls.connections({
        page: params.page,
        page_size: params.pageSize,
        sort_by: params.sortBy && sortByMap[params.sortBy],
        sort_direction: params.sortDirection,
      }),
    });

    return {
      total: data.total,
      data: data.data.map(mapConnectionResponse),
    };
  }

  async createConnection(
    this: ApiClient,
    params: C.CreateConnectionClient,
  ): Promise<C.CreateConnectionServer> {
    const data = await this.requestProtected<
      C.CreateConnectionRequest,
      C.CreateConnectionResponse
    >({
      method: 'POST',
      url: urls.connections(),
      body: {
        name: params.name,
        connector_id: params.connectorId,
        settings: params.settings,
      },
    });

    return mapCreateConnectionResponse(data);
  }

  async updateConnection(
    this: ApiClient,
    id: string,
    params: C.UpdateConnection,
  ): Promise<void> {
    await this.requestProtected<
      C.UpdateConnectionRequest,
      C.UpdateConnectionResponse
    >({
      method: 'PATCH',
      url: urls.connection(id),
      body: {
        name: params.name,
        settings: params.settings,
      },
    });
  }

  async deleteConnection(this: ApiClient, id: string): Promise<void> {
    await this.requestProtected<
      C.UpdateConnectionRequest,
      C.CreateConnectionResponse
    >({
      method: 'DELETE',
      url: urls.connection(id),
    });
  }
}