import { injectable } from "inversify";
import BlacklistItem, { IBlacklistItem, blacklistItemType, IBlacklistItemResource } from "./";
import { IJsonApiResource, IResourceMapper } from "../../interfaces";
import PartnerActivityMapper from "../partnerActivity/mapper";
import LodgingMapper from "../lodging/mapper";
import PoiMapper from "../poi/mapper";
import Mapper from "../../mapper";

const mappers = {
  lodging: new LodgingMapper(),
  partner_activity: new PartnerActivityMapper(),
  poi: new PoiMapper(),
};

@injectable()
export class BlacklistItemMapper extends Mapper<IBlacklistItem, IBlacklistItemResource> {

  toModel(resource: IBlacklistItemResource, included: IJsonApiResource[] = []): IBlacklistItem {
    const model = new BlacklistItem();
    const attrs = resource.attributes;

    model.id = resource.id;
    model.createdAt = attrs.created_at;
    model.updatedAt = attrs.updated_at;

    if (resource.relationships.target) {
      const targetResource = <IJsonApiResource>resource.relationships.target.data;
      model.target = this.mapIncluded(targetResource, included);
    }

    return model;
  }

  toResource(model: IBlacklistItem): IBlacklistItemResource {
    const resource: IBlacklistItemResource = {
      id: model.id,
      type: blacklistItemType,
      attributes: {
        created_at: model.createdAt,
        updated_at: model.updatedAt
      },
    };

    resource.relationships = {};

    if (model.target) {
      resource.relationships.target = {
        data: {
          type: model.target.type,
          id: model.target.id
        }
      };
    }

    Object.keys(resource.attributes).forEach((key) => {
      if (typeof resource.attributes[key] === "undefined") {
        delete resource.attributes[key];
      }
    });

    if (Object.keys(resource.relationships).length === 0) {
      delete resource.relationships;
    }

    return resource;
  }

  private mapIncluded(resourceIdentifier: IJsonApiResource, included: any[]) {
    const resource = included.find((i) =>
      i.type === resourceIdentifier.type && i.id === resourceIdentifier.id);

    if (!resource) {
      return resourceIdentifier;
    }

    const mapper: IResourceMapper<BlacklistItem, { [key: string]: any; }> = mappers[resource.type];
    return mapper.toModel(resource, included);
  }
}

export default BlacklistItemMapper;