nitro/apps/frontend/src/api/avatar/CategoryBaseModel.ts

import {AvatarEditorUtilities} from "./AvatarEditorUtilities";
import {CategoryData} from "./CategoryData";
import {IAvatarEditorCategoryModel} from "./IAvatarEditorCategoryModel";

export class CategoryBaseModel implements IAvatarEditorCategoryModel {
  protected _categories: Map<string, CategoryData>;
  protected _isInitalized: boolean;
  protected _maxPaletteCount: number;
  private _disposed: boolean;

  constructor() {
    this._isInitalized = false;
    this._maxPaletteCount = 0;
  }

  public dispose(): void {
    this._categories = null;
    this._disposed = true;
  }

  public get disposed(): boolean {
    return this._disposed;
  }

  public init(): void {
    if (!this._categories) this._categories = new Map();
  }

  public reset(): void {
    this._isInitalized = false;

    if (this._categories) {
      for (const category of this._categories.values()) category && category.dispose();
    }

    this._categories = new Map();
  }

  protected addCategory(name: string): void {
    let existing = this._categories.get(name);

    if (existing) return;

    existing = AvatarEditorUtilities.createCategory(this, name);

    if (!existing) return;

    this._categories.set(name, existing);

    this.updateSelectionsFromFigure(name);
  }

  protected updateSelectionsFromFigure(figure: string): void {
    const category = this._categories.get(figure);

    if (!category) return;

    const setId = AvatarEditorUtilities.CURRENT_FIGURE.getPartSetId(figure);

    let colorIds = AvatarEditorUtilities.CURRENT_FIGURE.getColorIds(figure);

    if (!colorIds) colorIds = [];

    category.selectPartId(setId);
    category.selectColorIds(colorIds);
  }

  public hasClubSelectionsOverLevel(level: number): boolean {
    if (!this._categories) return false;

    for (const category of this._categories.values()) {
      if (!category) continue;

      if (category.hasClubSelectionsOverLevel(level)) return true;
    }

    return false;
  }

  public hasInvalidSelectedItems(ownedItems: number[]): boolean {
    if (!this._categories) return false;

    for (const category of this._categories.values()) {
      if (category.hasInvalidSelectedItems(ownedItems)) return true;
    }

    return false;
  }

  public stripClubItemsOverLevel(level: number): boolean {
    if (!this._categories) return false;

    let didStrip = false;

    for (const [name, category] of this._categories.entries()) {
      let isValid = false;

      if (category.stripClubItemsOverLevel(level)) isValid = true;

      if (category.stripClubColorsOverLevel(level)) isValid = true;

      if (isValid) {
        const partItem = category.getCurrentPart();

        if (partItem && AvatarEditorUtilities.CURRENT_FIGURE) {
          AvatarEditorUtilities.CURRENT_FIGURE.savePartData(name, partItem.id, category.getSelectedColorIds(), true);
        }

        didStrip = true;
      }
    }

    return didStrip;
  }

  public stripInvalidSellableItems(): boolean {
    if (!this._categories) return false;

    let didStrip = false;

    for (const [name, category] of this._categories.entries()) {
      const isValid = false;

      // if(category._Str_8360(this._Str_2278.manager.inventory)) _local_6 = true;

      if (isValid) {
        const partItem = category.getCurrentPart();

        if (partItem && AvatarEditorUtilities.CURRENT_FIGURE) {
          AvatarEditorUtilities.CURRENT_FIGURE.savePartData(name, partItem.id, category.getSelectedColorIds(), true);
        }

        didStrip = true;
      }
    }

    return didStrip;
  }

  public selectPart(category: string, partIndex: number): void {
    const categoryData = this._categories.get(category);

    if (!categoryData) return;

    const selectedPartIndex = categoryData.selectedPartIndex;

    categoryData.selectPartIndex(partIndex);

    const partItem = categoryData.getCurrentPart();

    if (!partItem) return;

    if (partItem.isDisabled) {
      categoryData.selectPartIndex(selectedPartIndex);

      // open hc window

      return;
    }

    this._maxPaletteCount = partItem.maxColorIndex;

    AvatarEditorUtilities.CURRENT_FIGURE.savePartData(category, partItem.id, categoryData.getSelectedColorIds(), true);
  }

  public selectColor(category: string, colorIndex: number, paletteId: number): void {
    const categoryData = this._categories.get(category);

    if (!categoryData) return;

    const paletteIndex = categoryData.getCurrentColorIndex(paletteId);

    categoryData.selectColorIndex(colorIndex, paletteId);

    const colorItem = categoryData.getSelectedColor(paletteId);

    if (colorItem.isDisabled) {
      categoryData.selectColorIndex(paletteIndex, paletteId);

      // open hc window

      return;
    }

    AvatarEditorUtilities.CURRENT_FIGURE.savePartSetColourId(category, categoryData.getSelectedColorIds(), true);
  }

  public getCategoryData(category: string): CategoryData {
    if (!this._isInitalized) this.init();

    if (!this._categories) return null;

    return this._categories.get(category);
  }

  public get categories(): Map<string, CategoryData> {
    return this._categories;
  }

  public get canSetGender(): boolean {
    return false;
  }

  public get maxPaletteCount(): number {
    return this._maxPaletteCount || 1;
  }

  public set maxPaletteCount(count: number) {
    this._maxPaletteCount = count;
  }

  public get name(): string {
    return null;
  }
}