Auto report puzzles with multiple solutions

app/controllers/Puzzle.scala

@@ -249,6 +249,15 @@ final class Puzzle(env: Env, apiC: => Api) extends LilaController(env):
       )
   }
 
+  def report(id: PuzzleId) = AuthBody { _ ?=> me ?=>
+    NoBot:
+      bindForm(env.puzzle.forms.report)(
+        doubleJsonFormError,
+        reportText =>
+          env.puzzle.api.report.upsert(id).flatMap(_.so(env.irc.api.reportPuzzle(me.light, id,reportText))).inject(jsonOkResult)
+      )
+  }
+
   def voteTheme(id: PuzzleId, themeStr: String) = AuthBody { _ ?=> me ?=>
     NoBot:
       PuzzleTheme

conf/base.conf

@@ -124,6 +124,7 @@ puzzle {
     puzzle = puzzle2_puzzle
     round = puzzle2_round
     path = puzzle2_path
+    report = puzzle2_report
   }
 }
 relay {

conf/routes

@@ -173,6 +173,7 @@ GET   /training/:angle/$color<white|black|random> controllers.Puzzle.angleAndCol
 GET   /training/:angle/$id<\w{5}>      controllers.Puzzle.showWithAngle(angle, id: PuzzleId)
 POST  /training/$numericalId<\d{6,}>/round2    controllers.Puzzle.mobileBcRound(numericalId: Long)
 POST  /training/$id<\w{5}>/vote        controllers.Puzzle.vote(id: PuzzleId)
+POST  /training/$id<\w{5}>/report      controllers.Puzzle.report(id: PuzzleId)
 POST  /training/$id<\w{5}>/vote/:theme controllers.Puzzle.voteTheme(id: PuzzleId, theme)
 POST  /training/complete/:theme/$id<\w{5}>  controllers.Puzzle.complete(theme, id: PuzzleId)
 POST  /training/difficulty/:theme      controllers.Puzzle.setDifficulty(theme)

modules/irc/src/main/IrcApi.scala

@@ -105,6 +105,10 @@ final class IrcApi(
     zulip(_.content, "/opening edits"):
       s"${markdown.userLink(user)} edited ${markdown.lichessLink(s"/opening/$opening/$moves", opening)}"
 
+  def reportPuzzle(user: LightUser, puzzleId: PuzzleId, reportText: String): Funit =
+    zulip(_.content, "puzzle reports"):
+      s"${markdown.userLink(user)} reported ${markdown.lichessLink(s"/training/$puzzleId", puzzleId)} because $reportText"
+
   def broadcastStart(id: RelayRoundId, fullName: String): Funit =
     zulip(_.broadcast, "non-tiered broadcasts"):
       s":note: ${markdown.broadcastLink(id, fullName)}"

modules/puzzle/src/main/Env.scala

@@ -12,7 +12,8 @@ private class PuzzleConfig(
     @ConfigName("mongodb.uri") val mongoUri: String,
     @ConfigName("collection.puzzle") val puzzleColl: CollName,
     @ConfigName("collection.round") val roundColl: CollName,
-    @ConfigName("collection.path") val pathColl: CollName
+    @ConfigName("collection.path") val pathColl: CollName,
+    @ConfigName("collection.report") val reportColl: CollName
 )
 
 @Module
@@ -37,7 +38,8 @@ final class Env(
   val colls = new PuzzleColls(
     puzzle = db(config.puzzleColl),
     round = db(config.roundColl),
-    path = db(config.pathColl)
+    path = db(config.pathColl),
+    report = db(config.reportColl)
   )
 
   private val gameJson: GameJson = wire[GameJson]
@@ -112,5 +114,6 @@ final class Env(
 final class PuzzleColls(
     val puzzle: AsyncColl,
     val round: AsyncColl,
-    val path: AsyncColl
+    val path: AsyncColl,
+    val report: AsyncColl
 )

modules/puzzle/src/main/PuzzleApi.scala

@@ -37,6 +37,25 @@ final class PuzzleApi(
     def setIssue(id: PuzzleId, issue: String): Fu[Boolean] =
       colls.puzzle(_.updateField($id(id), Puzzle.BSONFields.issue, issue).map(_.n > 0))
 
+  object report:
+    // return `true` if missing
+    def upsert(id: PuzzleId): Fu[Boolean] =
+      colls
+        .puzzle(_.exists($id(id)))
+        .flatMap(
+          _.so(
+            colls.report(
+              _.update
+                .one(
+                  $id(id),
+                  $doc("reported" -> true),
+                  upsert = true
+                )
+                .map(_.upserted.nonEmpty)
+            )
+          )
+        )
+
   private[puzzle] object round:
 
     def find(user: User, puzzleId: PuzzleId): Fu[Option[PuzzleRound]] =

modules/puzzle/src/main/PuzzleForm.scala

@@ -37,6 +37,10 @@ object PuzzleForm:
     single("vote" -> boolean)
   )
 
+  val report = Form(
+    single("reason" -> nonEmptyText(1,200))
+  )
+
   val themeVote = Form(
     single("vote" -> optional(boolean))
   )

ui/puzzle/src/ctrl.ts

@@ -6,6 +6,7 @@ import moveTest from './moveTest';
 import PuzzleSession from './session';
 import PuzzleStreak from './streak';
 import { throttle } from 'common/timing';
+// import * as licon from 'common/licon';
 import {
   PuzzleOpts,
   PuzzleData,
@@ -78,6 +79,8 @@ export default class PuzzleCtrl implements ParentCtrl {
   voteDisabled?: boolean;
   isDaily: boolean;
   blindfolded = false;
+  // if local eval suspect multiple solutions, report the puzzle
+  reportedForMultipleSolutions = false;
 
   constructor(
     readonly opts: PuzzleOpts,
@@ -125,6 +128,7 @@ export default class PuzzleCtrl implements ParentCtrl {
             if (!node.threat || node.threat.depth <= threat.depth) node.threat = threat;
           } else if (!node.ceval || node.ceval.depth <= ev.depth) node.ceval = ev;
           if (work.path === this.path) {
+            this.reportIfMultipleSolutions(ev);
             this.setAutoShapes();
             this.redraw();
           }
@@ -463,6 +467,79 @@ export default class PuzzleCtrl implements ParentCtrl {
 
   private isPuzzleData = (d: PuzzleData | ReplayEnd): d is PuzzleData => 'puzzle' in d;
 
+  // take the eval as arg instead of taking it from the node to be sure it's the most up to date
+  // All non-mates puzzle should have one and only one solution, if that is not the case, report it back to backend
+  private reportIfMultipleSolutions = (ev: Tree.ClientEval): void => {
+    // if the eval depth is superior to 20, we're on the puzzle solution and two moves are good
+    // that is an absolute eval superior to 4, then log it
+    console.log('ev', ev, 'node', this.node);
+    // first, make sure we're in view mode so we know the solution is the mainline
+    // do not check, checkmate puzzles
+    if (
+      !this.session.userId ||
+      this.reportedForMultipleSolutions ||
+      this.mode != 'view' ||
+      this.threatMode() ||
+      // the `mate` key theme is not sent, as it is considered redubant with `mateInX`
+      this.data.puzzle.themes.some((t: ThemeKey) => t.toLowerCase().includes('mate'))
+    )
+      return;
+    console.log('good mode');
+    // know we want to check that we're evaluating from the opponent side, so that multiPV show moves for the solving
+    // side. We also want to check we're at the first ply of the puzzle or later.
+    const node = this.node;
+    // more resilient than checking the turn directly, if eventually puzzle get generated from position games
+    const nodeTurn = node.fen.includes(' w ') ? 'white' : 'black';
+    if (
+      node.ply >= this.initialNode.ply &&
+      nodeTurn == this.pov &&
+      this.mainline.some(n => n.id == node.id)
+    ) {
+      console.log('correct position!');
+      // if second pv.cp is > 400, it's a multi solution puzzle
+      const invertIfBlack = (cp: number) => (this.pov == 'white' ? cp : -cp);
+      console.log('ev.depth > 20', ev!.depth > 20, 'ev.depth > 20');
+      if (ev.pvs[1]?.cp) {
+        console.log(
+          'ev!.pvs[1]!.cp',
+          ev.pvs[1].cp,
+          'ev.pvs[1].cp  >= cpThreshold',
+          invertIfBlack(ev.pvs[1].cp) >= 400,
+        );
+      }
+      // TODO probably check what are really the conditions for a puzzle to have multiple solutions
+      if (ev.depth > 20 && ev.pvs[1]?.cp && invertIfBlack(ev.pvs[1].cp) >= 400) {
+      //   this.reportedForMultipleSolutions = true;
+      //   //this.reportDialog()
+      //   // POST  /training/$id<\w{5}>/report      controllers.Puzzle.report(id: PuzzleId)
+        const reason = `Move ${node.san}, depth ${ev.depth}, pvs ${ev.pvs.map(pv => `${pv.moves[0]}: ${pv.cp}`).join(', ')}`;
+        xhr.report(this.data.puzzle.id, reason)
+      }
+    }
+  };
+
+  // TODO FIXME, does not work, dialogs...
+  // private reportDialog = () => {
+  //   // html form yes/no report with a checkbox 'do not show this again for a week'
+  //   domDialog({
+  //     show: 'modal',
+  //     htmlText:
+  //       '<div><strong style="font-size:1.5em">' +
+  //       'Report multiple solutions' +
+  //       '</strong><br /><br />' +
+  //       '<pre>' +
+  //       'You have found a puzzle with multiple solutions, report it?' +
+  //       '</pre><br />' +
+  //       '<br /><br />' +
+  //       `<button type="reset" class="button button-empty button-red text reset" data-icon="${licon.X}">No</button>` +
+  //       `<button type="submit" class="button button-green text apply" data-icon="${licon.Checkmark}">Yes</button>`,
+  //   }).then(_dlg => {
+  //     // No overload matches this call.
+  //     // $('.reset', dlg.view).on('click', dlg.close());
+  //     // dlg.showModal();
+  //   });
+  // };
+
   nextPuzzle = (): void => {
     if (this.streak && this.lastFeedback != 'win') {
       if (this.lastFeedback == 'fail') site.redirect(router.withLang('/streak'));

ui/puzzle/src/xhr.ts

@@ -37,6 +37,12 @@ export const voteTheme = (puzzleId: string, theme: ThemeKey, vote: boolean | und
     body: defined(vote) ? xhr.form({ vote }) : undefined,
   });
 
+export const report = (puzzleId: string, reason: string): Promise<void> =>
+  xhr.json(`/training/${puzzleId}/report`, {
+    method: 'POST',
+    body: xhr.form({ reason: reason }),
+  });
+
 export const setZen = throttlePromiseDelay(
   () => 1000,
   zen =>