ConceptCreator/src/app/app.component.ts

import {Component, NgZone, OnInit, ViewChild} from '@angular/core';
import {MatDrawerContainer} from "@angular/material/sidenav";
import {EditorComponent} from "./editor/editor.component";
import {
  ScriptAccountOverviewComponent
} from "./side-overviews/script-account-overview/script-account-overview.component";
import {MatDialog} from "@angular/material/dialog";
import {DeleteConfirmationDialogComponent} from "./delete-confirmation-dialog/delete-confirmation-dialog.component";
import {GamescriptOverviewComponent} from "./side-overviews/gamescript-overview/gamescript-overview.component";
import {ModelComponentType} from "./project/game-model/ModelComponentType";
import {ModelComponentTypeUtillities} from "./project/game-model/ModelComponentTypeUtillities";
import {ScriptAccount} from "./project/game-model/scriptAccounts/ScriptAccount";
import {Gamesystem} from "./project/game-model/gamesystems/Gamesystem";
import {ModelComponent} from "./project/game-model/ModelComponent";
import {GameModel} from "./project/game-model/GameModel";
import {StoredGameModel} from "../../app/storage/StoredGameModel";
import {GamesystemParser} from "./project/parser/gamesystemParser/GamesystemParser";
import {ScriptAccountParser} from "./project/parser/ScriptAccountParser";
import {ElectronService} from "./core/services";
import {ScriptAccountSerializer} from "./project/serializer/ScriptAccountSerializer";
import {StoreComponent} from "../../app/storage/StoreComponent";
import {GamesystemSerializer} from "./project/serializer/GamesystemSerializer";

@Component({
  selector: 'app-root',
  templateUrl: './app.component.html',
  styleUrls: ['./app.component.css']
})
export class AppComponent implements OnInit{

  openContent : ModelComponentType | undefined = undefined;
  @ViewChild('drawer') drawer: MatDrawerContainer|undefined
  @ViewChild('editor') editor: EditorComponent|undefined
  @ViewChild('scriptAccountOverview') scriptAccountOverview: ScriptAccountOverviewComponent | undefined
  @ViewChild('gamesystemOverview') gamesystemOverview: GamescriptOverviewComponent | undefined

  gameModel: GameModel | undefined

  constructor(private electronService: ElectronService,
              private dialog: MatDialog,
              private zone: NgZone
  ) {
    if(electronService.isElectron) {
      electronService.ipcRenderer.on('context-menu', (event: any, message: string) => {
        this.zone.run(() => {
          this.onContextMenuMessageRecieved(message);
        });
      })

      electronService.ipcRenderer.on('get-project-data', (event: any, message: string) => {
        this.zone.run(() => {
          this.onSaveProject();
        })
      })

      electronService.ipcRenderer.on('open-project', (event: any, loadedProject: StoredGameModel) => {
        this.zone.run(() => {
          this.onLoadProject(loadedProject)
        })
      })


    }
  }

  onContextMenuMessageRecieved(message: string) {
    if(message == "edit") {
      this.onEditModelComponent();
    } else if(message == "delete") {
      this.onDeleteModelComponent();
    } else if(message.startsWith("new")) {
      const splittedMessage = message.split("-");
      const modelComponentType = ModelComponentTypeUtillities.fromString(splittedMessage[1]);
      if(modelComponentType != undefined) {
        this.onCreateModelComponent(modelComponentType);
      } else {
        console.log("[ERROR] [App-Component] Unknown Context-Menu Command!")
      }
    }
  }

  private onEditModelComponent() {
    switch (this.openContent!) {
      case ModelComponentType.SCRIPTACCOUNT: {
        if(this.scriptAccountOverview!.selectedScriptAccount != undefined) {
          this.editor!.openGameModelComponent(this.scriptAccountOverview!.selectedScriptAccount);
        }
      } break;
      case ModelComponentType.GAMESYTEM: {
        if(this.gamesystemOverview!.selectedGamesystem != undefined) {
          const gamesystem = this.gameModel!.findGamesystem(this.gamesystemOverview!.selectedGamesystemName!);
          this.editor!.openGameModelComponent(gamesystem!);
        }
      } break
    }
  }

  private onDeleteModelComponent() {
    const affectedModelComponent = this.getSelectedModelComponent();
    console.log("Affected ModelComponent: ", affectedModelComponent)
    const dialogRef = this.dialog.open(DeleteConfirmationDialogComponent, {data: affectedModelComponent, minWidth: "400px"});

    dialogRef.afterClosed().subscribe(res => {
      if(res != undefined && res) {
        if(affectedModelComponent instanceof ScriptAccount) {
          this.gameModel!.removeScriptAccount(affectedModelComponent);
          //this.electronService.ipcRenderer.send('delete-component', new DeleteModel(affectedModelComponent.componentName, ModelComponentType.SCRIPTACCOUNT))
        } else if(affectedModelComponent instanceof Gamesystem) {
          this.gameModel!.removeGamesystem(affectedModelComponent);
          //this.electronService.ipcRenderer.send('delete-component', new DeleteModel(affectedModelComponent.componentName, ModelComponentType.GAMESYTEM))
          this.gamesystemOverview!.refresh()
        }
      }
    })
  }

  private onCreateModelComponent(modelComponentType: ModelComponentType) {
    switch (modelComponentType) {
      case ModelComponentType.SCRIPTACCOUNT: this.onCreateNewScriptAccount(); break
      case ModelComponentType.GAMESYTEM: this.onCreateNewGamesystem(); break
    }
  }

  private onCreateNewScriptAccount() {
    const createdScriptAccount = this.gameModel!.createScriptAccount("New ScriptAccount");
    if(createdScriptAccount != undefined) {
      this.editor?.openGameModelComponent(createdScriptAccount);
    } else {
      console.log("[DEBUG] [App-Component] ScriptAccount could not be created (Name not unique)");
    }
  }

  private onCreateNewGamesystem() {
    let parentGamesystemName = undefined
    if(this.openContent != ModelComponentType.GAMESYTEM) {
      this.openGamesystemsOverview();
    } else {
      parentGamesystemName = this.gamesystemOverview!.selectedGamesystemName;
    }


    const createdGamesystem = this.gameModel!.createGamesystem("New Gamesystem", parentGamesystemName);
    if(createdGamesystem != undefined) {
      this.gamesystemOverview!.refresh();
      this.editor?.openGameModelComponent(createdGamesystem);
    }
  }

  private getSelectedModelComponent(): ModelComponent | undefined {
    if(this.openContent == ModelComponentType.SCRIPTACCOUNT) {
      if(this.scriptAccountOverview != undefined) {
        return this.scriptAccountOverview.selectedScriptAccount;
      } else {
        console.log("[WARN] [App.component] ScriptAccountOverview is undefined")
      }
    } else if(this.openContent == ModelComponentType.GAMESYTEM){
      if(this.gamesystemOverview != undefined) {
        return this.gamesystemOverview.getSelectedGamesystem()
      } else {
        console.log("[WARN] [App.component] GamesystemOverview is undefined")
      }
    }
    return undefined;
  }

  ngOnInit() {

  }

  onLoadProject(storedGameModel: StoredGameModel) {
    const gameModel = new GameModel(storedGameModel.gameModelName)

    const scriptAccounts = ScriptAccountParser.parseScriptAccounts(storedGameModel.storedScriptAccounts);

    const gamesystemParser = new GamesystemParser(scriptAccounts);
    const gamesystems = gamesystemParser.parseStoredGamesystems(storedGameModel.storedGamesystems);

    gameModel.scriptAccounts = scriptAccounts
    gameModel.gamesystems = gamesystems
    gameModel.generateProductSystemContents()

    console.log(gameModel.scriptAccounts)

    this.gameModel = gameModel;
  }

  onSaveProject() {
   if(this.gameModel != undefined) {
     const storedScriptAccounts = ScriptAccountSerializer.serializeScriptAccounts(this.gameModel.scriptAccounts)
     const storedGamesystems: StoreComponent[] =     GamesystemSerializer.serializeGamesystems(this.gameModel.gamesystems)
     const storeModel = new StoredGameModel(this.gameModel.gameModelName, storedScriptAccounts, storedGamesystems)

     if(this.electronService.isElectron) {
       this.electronService.ipcRenderer.send('save-model', storeModel)
     }
   }
  }

  openScriptAccountsOverview() {
    this.openContent = ModelComponentType.SCRIPTACCOUNT
    this.drawer!.open();
  }

  openGamesystemsOverview() {
    this.openContent = ModelComponentType.GAMESYTEM;
    this.drawer!.open();
  }

  openCharactersOverview() {
    this.openContent = ModelComponentType.CHARACTER
    this.drawer!.open()
  }

  protected readonly ModelComponentType = ModelComponentType;

  closeContentOverview() {
    this.drawer!.close();
    this.openContent = undefined;
  }

  protected readonly ModelComponentTypeUtillities = ModelComponentTypeUtillities;

  openModelComponent(modelComponent: ModelComponent) {
    if(this.editor != undefined) {
      this.editor.openGameModelComponent(modelComponent);
    } else {
      console.log("[WARN] [App.Component] Editor is undefined")
    }
  }

  onModelNameUpdate() {
    if(this.openContent == ModelComponentType.GAMESYTEM) {
      this.gamesystemOverview!.refresh();
    }
  }

  resetSelection() {
    if(this.gamesystemOverview != undefined) {
      this.gamesystemOverview.resetSelectedGamesystem()
    }
  }
}