recipe.ts.bak

import { Injectable } from '@angular/core';

import { IItem, IIngredient } from './types';

import BUILTINS from './item-builtins.json';

@Injectable()
export class ItemDatabase {

  private items: IItem[];

  constructor() {
    this.refreshDB();
  }

  public refreshDB(): void {
    const local = this.getLocalStorage();
    if (local.length) {
      this.items = local;
    } else {
      this.items = this.getBuiltins();
    }
    // const builtins = this.getBuiltins();
    // this.items = ([] as any).concat(
    //   this.getBuiltins(),
    //   this.getLocalStorage(),
    // );
  }

  public all(): IItem[] {
    return this.items;
  }

  public add(item: IItem) {
    const base = this.getBaseIngredients(item);
    // console.log(`Setting base ingredients for ${item.id} to:`, base);
    item.baseIngredients = base;

    console.log(item);

    // const idx = this.items.findIndex((i) => i.id === item.id);
    // if (idx === -1) {
    //   this.items.push(item);
    // } else {
    //   this.items[idx] = item;
    // }

    // this.saveItems();
  }

  public import(text: string): void {
    localStorage.setItem('items', text);
    this.refreshDB();
  }

  public remove(item: IItem): void {
    this.removeByID(item.id);
  }

  public removeByID(id: string): void {
    const idx = this.items.findIndex((i) => i.id === id);
    if (idx) {
      this.items.splice(idx, 1);
    }

    this.saveItems();
  }

  public resetToDefault(): void {
    localStorage.removeItem('items');
    this.refreshDB();
  }

  public getItemByID(id: string): IItem | undefined {
    return this.items.find((item) => item.id === id);
  }

  private getBuiltins(): IItem[] {
    const builtins = BUILTINS as IItem[];
    return BUILTINS;
  }

  private getLocalStorage(): IItem[] {
    return JSON.parse(localStorage.getItem('items')!) || [];
  }

  private saveItems(): void {
    localStorage.setItem('items', JSON.stringify(this.items));
  }

  private getBaseIngredients(item: IItem): IIngredient[] | undefined {
    const baseIngredients: IIngredient[] = [];
    const baseMap: Map<string, number> = new Map();

    // console.log('Getting base ingredients for: ' + item.id);
    // console.log(item.baseIngredients);
    if (item.baseIngredients) {
      return item.baseIngredients;
    }

    if (item.recipe) {
      item.recipe.ingredients.forEach((ingredient) => {
        // console.log('getting base ingredients for subingredient: ' + ingredient.item);
        // Could check for base ingredients of each ingredient for speed
        this.getBaseIngredientsHelper(ingredient, baseMap, 1, item.recipe.outputCount);
      });
      // this.getBaseIngredientsHelper({ count: 1, item: item.id }, baseIngredients, 1, 1);
    } else {
      return;
    }

    baseMap.forEach((count, itemID) => {
      baseIngredients.push({ count, itemID });
    });
    return baseIngredients;
  }

  private getBaseIngredientsHelper(ingredient: IIngredient, baseMap: Map<string, number>, parentCount: number, parentRecipeOutput: number): void {
    // console.log('helper:', ingredient);
    const item = this.getItemByID(ingredient.itemID);
    // console.log(item);
    if (!item) {
      throw new Error(`Can't find item with ID: ${ingredient.itemID}`);
    }

    const count = Math.ceil(parentCount / parentRecipeOutput) * ingredient.count;

    if (!item.recipe) {
      // Is base item
      // console.log('is base item', parentCount, parentRecipeOutput, ingredient.count);
      const previousCount = baseMap.get(ingredient.itemID) || 0;
      baseMap.set(ingredient.itemID, previousCount + count);
      return;
    }

    item.recipe.ingredients.forEach((subIngredient) => {
      this.getBaseIngredientsHelper(subIngredient, baseMap, count, item.recipe!.outputCount);
    });
  }

}