import { inject, injectable } from "inversify";
import BaseService from "../../service";
import { IService, IResourceMapper, IJsonApiResource, IFindParams } from "../../interfaces";
import {
  ITag, ITagResource, ITagAssociationResource, tagType, ITagAssociationResponse,
  ITopic, ITopicResource, ITopicResponse
} from "./";
import Mapper from "./mapper";
import TopicMapper from "./topicMapper";

export interface ITagService extends IService<ITag> {
  addTagToResource(tag: ITag): Promise<ITag>;
  findByResource(id: string, type: string, options?: IFindParams): Promise<ITag[]>;
  deleteAssociation(id: string): void;
  findTopic(options?: IFindParams): Promise<ITopic[]>;
}

@injectable()
export default class TagService extends BaseService<ITag, ITagResource | ITagAssociationResource> implements ITagService {
  resource: string = tagType;
  mapper: IResourceMapper<ITag, ITagResource | ITagAssociationResource> = new Mapper();
  topicMapper: IResourceMapper<ITopic, ITopicResource> = new TopicMapper();

  public url() {
    return `${this.host}/tags`;
  }

  public tagAssociationUrl() {
    return `${this.host}/tags/associations`;
  }

  public async findByResource(id: string, type: string, options: IFindParams = {}) {
    const resources = await this.http.fetch<ITagAssociationResponse>(
      `${this.tagAssociationUrl()}${this.qs({
        ...options,
        resource: "tag_association",
        tag_type: "tag",
        target_id: id,
        target_type: type,
      })}`,
      {
        headers: this.headers(),
      }
    );

    return <ITag[]>this.mapper.map(resources);
  }

  public async addTagToResource(tag: ITag): Promise<ITag> {
    const resource = await this.http.fetch<ITagAssociationResponse>(
      this.tagAssociationUrl(), {
        method: "POST",
        body: {
          data: {
            ...this.mapper.toResource(tag),
          },
        },
        headers: this.headers(),
      }
    );
    tag.associationId = (<IJsonApiResource>resource.data).id;

    return tag;
  }

  public async deleteAssociation(id) {
    const url = `${this.tagAssociationUrl()}/${id}`;

    await this.http.fetch(
      url,
      {
        method: "DELETE",
        headers: this.headers(),
      });

    return;
  }

  public async findTopic(options?: IFindParams): Promise<ITopic[]> {
    const resources = await this.http.fetch<ITopicResponse>(
      `${this.url()}/topics${this.qs({ ...options, resource: "topic"})}`,
      {
        headers: this.headers(),
      }
    );

    return <ITopic[]>this.topicMapper.map(resources);
  }

  public headers() {
    return {
      ...super.headers(),
      "Accept-Version": "v2",
    }
  }
}