import { HasManyInterface, BaseRequestModelInterface } from '../interfaces';
import { Id, Methods, Shape, Count } from '../../types';
import { combineUrl } from '../../helpers';

type BelongsToOptions<P> = {
  parent: BaseRequestModelInterface<P>;
  targetPath: string;
};

export class HasManyModel<T, P> implements HasManyInterface<T> {
  parent: BaseRequestModelInterface<P>;
  targetPath: string;

  constructor(options: BelongsToOptions<P>) {
    this.parent = options.parent;
    this.targetPath = options.targetPath;

    this.getAll = this.getAll.bind(this);
    this.post = this.post.bind(this);
    this.patchAll = this.patchAll.bind(this);
    this.delAll = this.delAll.bind(this);
  }

  async getAll(parentId: Id, filter?: Shape): Promise<Array<T>> {
    return this.parent.request<Array<T>>({
      url: combineUrl(this.parent.basePath, `${parentId}`, this.targetPath),
      method: Methods.GET,
      params: filter ? { filter } : undefined,
    });
  }

  async post(parentId: Id, item: Omit<T, 'id'>): Promise<T> {
    return this.parent.request<T>({
      url: combineUrl(this.parent.basePath, `${parentId}`, this.targetPath),
      method: Methods.POST,
      data: item,
    });
  }

  patchAll(parentId: Id, item: Partial<T>, where?: Shape): Promise<Count> {
    return this.parent.request<Count>({
      url: combineUrl(this.parent.basePath, `${parentId}`, this.targetPath),
      method: Methods.PATCH,
      data: item,
      params: where ? { where } : undefined,
    });
  }

  delAll(parentId: Id, where?: Shape): Promise<Count> {
    return this.parent.request<Count>({
      url: combineUrl(this.parent.basePath, `${parentId}`, this.targetPath),
      method: Methods.DELETE,
      params: where ? { where } : undefined,
    });
  }
}