feat: NCWF-5/6/7/8/9 chess analysis page and engine integration (#11)

Co-authored-by: Janis Eccarius <eccariusjanis@gmail.com>
Reviewed-on: #11

src/app/pages/tournaments/tournaments.component.ts

@@ -1,11 +1,13 @@
 import { Component, DestroyRef, OnInit, inject } from '@angular/core';
-import { CommonModule } from '@angular/common';
+import { CommonModule, TitleCasePipe } from '@angular/common';
 import { Router, RouterLink } from '@angular/router';
-import { FormBuilder, FormGroup, ReactiveFormsModule, Validators } from '@angular/forms';
+import { FormBuilder, FormGroup, FormsModule, ReactiveFormsModule, Validators } from '@angular/forms';
 import { takeUntilDestroyed } from '@angular/core/rxjs-interop';
 import { TournamentService } from '../../services/tournament.service';
 import { AuthService } from '../../services/auth.service';
 import { BotService } from '../../services/bot.service';
+import { OfficialBotService } from '../../services/official-bot.service';
+import { TournamentServerService, ExternalTournamentServer } from '../../services/tournament-server.service';
 import { Bot } from '../../models/bot.models';
 import { Tournament, TournamentResult, RoundPairings } from '../../models/tournament.models';
 import { CurrentUser } from '../../models/auth.models';
@@ -15,7 +17,7 @@ type StatusTab = 'started' | 'created' | 'finished';
 @Component({
   selector: 'app-tournaments',
   standalone: true,
-  imports: [CommonModule, RouterLink, ReactiveFormsModule],
+  imports: [CommonModule, RouterLink, FormsModule, ReactiveFormsModule, TitleCasePipe],
   templateUrl: './tournaments.component.html',
   styleUrl: './tournaments.component.css'
 })
@@ -25,6 +27,8 @@ export class TournamentsComponent implements OnInit {
   private readonly authService = inject(AuthService);
   private readonly fb = inject(FormBuilder);
   private readonly botService = inject(BotService);
+  private readonly officialBotService = inject(OfficialBotService);
+  private readonly tournamentServerService = inject(TournamentServerService);
   private readonly router = inject(Router);
 
   loading = true;
@@ -58,6 +62,19 @@ export class TournamentsComponent implements OnInit {
   joiningBotId: string | null = null;
   joinError: string | null = null;
 
+  readonly officialDifficulties = ['easy', 'medium', 'hard', 'expert'] as const;
+  joiningOfficialDifficulty: string | null = null;
+  officialJoinError: string | null = null;
+
+  showServersDialog = false;
+  servers: ExternalTournamentServer[] = [];
+  serversLoading = false;
+  newServerLabel = '';
+  newServerUrl = '';
+  addingServer = false;
+  addServerError: string | null = null;
+  removingServerId: string | null = null;
+
   ngOnInit(): void {
     this.authService.currentUser$
       .pipe(takeUntilDestroyed(this.destroyRef))
@@ -170,6 +187,32 @@ export class TournamentsComponent implements OnInit {
     this.joinDialogTournamentId = null;
     this.joiningBotId = null;
     this.joinError = null;
+    this.joiningOfficialDifficulty = null;
+    this.officialJoinError = null;
+  }
+
+  joinWithOfficialBot(difficulty: string): void {
+    if (!this.joinDialogTournamentId || this.joiningOfficialDifficulty || this.joiningBotId) return;
+    this.joiningOfficialDifficulty = difficulty;
+    this.officialJoinError = null;
+    const tid = this.joinDialogTournamentId;
+    this.officialBotService.joinTournament(tid, difficulty).subscribe({
+      next: () => {
+        this.joiningOfficialDifficulty = null;
+        this.closeJoinDialog();
+        this.tournamentService.get(tid)
+          .pipe(takeUntilDestroyed(this.destroyRef))
+          .subscribe(updated => {
+            this.created = this.created.map(x => x.id === tid ? updated : x);
+            this.started = this.started.map(x => x.id === tid ? updated : x);
+            if (this.selectedTournament?.id === tid) this.selectedTournament = updated;
+          });
+      },
+      error: err => {
+        this.joiningOfficialDifficulty = null;
+        this.officialJoinError = err.error?.error ?? 'Failed to join with official bot.';
+      }
+    });
   }
 
   joinWithBot(bot: Bot): void {
@@ -196,6 +239,58 @@ export class TournamentsComponent implements OnInit {
     });
   }
 
+  openServersDialog(): void {
+    this.newServerLabel = '';
+    this.newServerUrl = '';
+    this.addServerError = null;
+    this.showServersDialog = true;
+    this.serversLoading = true;
+    this.tournamentServerService.list()
+      .pipe(takeUntilDestroyed(this.destroyRef))
+      .subscribe({
+        next: res => { this.servers = res.servers; this.serversLoading = false; },
+        error: () => { this.serversLoading = false; }
+      });
+  }
+
+  closeServersDialog(): void {
+    this.showServersDialog = false;
+  }
+
+  addServer(): void {
+    const label = this.newServerLabel.trim();
+    const url = this.newServerUrl.trim();
+    if (!label || !url || this.addingServer) return;
+    this.addingServer = true;
+    this.addServerError = null;
+    this.tournamentServerService.register(label, url).subscribe({
+      next: server => {
+        this.addingServer = false;
+        this.servers = [...this.servers, server];
+        this.newServerLabel = '';
+        this.newServerUrl = '';
+        this.loadTournaments();
+      },
+      error: err => {
+        this.addingServer = false;
+        this.addServerError = err.error?.error ?? 'Failed to add server.';
+      }
+    });
+  }
+
+  removeServer(id: string): void {
+    if (this.removingServerId) return;
+    this.removingServerId = id;
+    this.tournamentServerService.remove(id).subscribe({
+      next: () => {
+        this.removingServerId = null;
+        this.servers = this.servers.filter(s => s.id !== id);
+        this.loadTournaments();
+      },
+      error: () => { this.removingServerId = null; }
+    });
+  }
+
   private loadTournaments(): void {
     this.tournamentService.list()
       .pipe(takeUntilDestroyed(this.destroyRef))