import { AxiosInstance, AxiosRequestConfig } from 'axios';
import { Methods, Id, Shape, Count } from '../../types';
import { BaseRequestModelInterface } from '../interfaces';

export class BaseRequestModel<T> implements BaseRequestModelInterface<T> {
  protected api: AxiosInstance;
  public basePath: string;

  constructor(api: AxiosInstance, basePath: string) {
    this.api = api;
    this.basePath = basePath;

    this.request = this.request.bind(this);
    this.post = this.post.bind(this);
    this.getAll = this.getAll.bind(this);
    this.getById = this.getById.bind(this);
    this.count = this.count.bind(this);
    this.patchById = this.patchById.bind(this);
    this.patchAll = this.patchAll.bind(this);
    this.putById = this.putById.bind(this);
    this.deleteById = this.deleteById.bind(this);
  }

  async request<T>(config: AxiosRequestConfig): Promise<T> {
    const { data } = await this.api.request<T>(config);
    return data;
  }

  async post(item: Omit<T, 'id'>): Promise<T> {
    return this.request<T>({
      url: this.basePath,
      method: Methods.POST,
      data: item,
    });
  }

  async getAll(filter?: Shape): Promise<T[]> {
    return this.request<T[]>({
      url: this.basePath,
      params: filter ? { filter } : undefined,
      method: Methods.GET,
    });
  }

  async getById(id: Id, filter?: Shape): Promise<T> {
    return this.request<T>({
      url: `${this.basePath}/${id}`,
      method: Methods.GET,
      params: filter ? { filter } : undefined,
    });
  }

  async count(where?: Shape): Promise<Count> {
    return this.request<Count>({
      url: `${this.basePath}/count`,
      method: Methods.GET,
      params: where ? { where } : undefined,
    });
  }

  async patchById(id: Id, item: Partial<T>): Promise<void> {
    await this.request<undefined>({
      url: `${this.basePath}/${id}`,
      method: Methods.PATCH,
      data: item,
    });
  }

  async patchAll(item: Partial<T>, where?: Shape): Promise<Count> {
    return this.request<Count>({
      url: this.basePath,
      method: Methods.PATCH,
      data: item,
      params: where ? { where } : undefined,
    });
  }

  async putById(id: Id, item: T): Promise<void> {
    await this.request<undefined>({
      url: `${this.basePath}/${id}`,
      method: Methods.PUT,
      data: item,
    });
  }

  async deleteById(id: Id): Promise<void> {
    await this.request<void>({
      url: `${this.basePath}/${id}`,
      method: Methods.DELETE,
    });
  }
}