///////////////////////////
// Your API to work with //
///////////////////////////

sinterface GameForAI {
  S submit(S text); // returns correct solution so AI can learn from it
  bool compareSolutions(S a, S b);
}

abstract sclass AI {
  // stuff you get
  
  GameForAI game;
  RGBImage image;
  int steps;
  bool visualize = true;
  
  RGBImage image() { ret image; }
  BWImage bwImage() { ret new BWImage(image); }
  int w() { ret image.w(); }
  int h() { ret image.h(); }
  S submit(S text) { ret game.submit(text); }
  S submitNothing() { ret game.submit(null); }
  bool compareSolutions(S a, S b) { ret game.compareSolutions(a, b); }
  bool submitCorrectly(S text) { ret compareSolutions(text, submit(text)); }

  // implement this method and call submit()
  abstract void go();
  
  void done() {}
}

///////////////
// Main Game //
///////////////

static int rounds = 1000;
static bool alwaysNewImage = true; // prevents AIs being stuck on an image
static int fps = 50;
static bool showBlunderWindow = true;
static int blunderFPS = 20;

static new Game userGame;
static int halfTime;
static ImageSurface is, isWrong;
static long isWrongLast;
static RGBImage img;
static S solution;
volatile sbool aiMode;
static JLabel lblScore, lblTiming, lblInstruction;
static new HashMap<Class, AI> ais;
static S winner;
static JTextField tfSolution;

svoid pGame {
  substance();
  swing {
    thread { loadBinarySnippet(#1004373); } // preload applause animation
    lblInstruction = jcenteredBoldLabel();
    nextImage();
    addToWindowTop(is, withMargin(lblInstruction));
    addToWindow(is, withTopMargin(tfSolution = jCenteredTextField()));
    onEnter(tfSolution, r {
      userSaid(getTextTrim(tfSolution))
    });
    addToWindow(is, withMargin(lblScore = jcenteredBoldLabel("Your score: 0 of 0")));
    for (final Class c : myNonAbstractClassesImplementing(AI)) {
      final S name = shortClassName(c);
      final JButton btn = jbutton(name);
      onClick(btn, r {
        if (aiMode) ret;
        btn.setText(name + " Running...");
        thread {
          Game game = testAI(c, voidfunc(Game game) {
            if (game.step < 50 || (game.step % 10) == 0 || game.step == rounds) {
              S text = name + " scored " + game.points + " of " + game.step;
              if (game.step > halfTime)
                text += " (" + (game.points-game.halfTimeScore) + "/" + (game.step-halfTime) + ")";
              if (game.error != null)
                text += " - ERROR: " + game.error;
              setText_noWait(btn, text);
            }
          });
        }
      });
      addToWindow(is, withMargin(btn));
    }
    addToWindow(is, lblTiming = jCenteredLabel(;
    titlePopupMenuItem(is, "Show Winner Code", f showWinnerCode);
    titlePopupMenuItem(is, "Restart AIs", r { clearMapWithCleanUp(ais); });
    titlePopupMenuItem(is, jCheckBoxMenuItem("Show Blunder Window", showBlunderWindow, r { showBlunderWindow = !showBlunderWindow; }));
    addToWindow(is, withMargin(jbutton("Restart AIs", r { clearMapWithCleanUp(ais); })));
    
    packFrame(is);
    setFrameWidth(is, 400);
    centerTopFrame(is);
    hideConsole();
  }
}

sclass Puzzle {
  S instruction;
  RGBImage image;
  S solution;
  
  *() {}
  *(S *instruction, BufferedImage image, S *solution) {
    this.image = new RGBImage(image);
  }
  *(S *instruction, RGBImage *image, S *solution) {}
}

svoid nextImage {
  Puzzle puzzle = makePuzzle();
  setText(lblInstruction, or2(puzzle.instruction, "?"));
  assertNotNull("Image is null", puzzle.image);
  main.img = puzzle.image;
  solution = puzzle.solution;
  if (aiMode) ret; // occasional updates only when AI is running
  showTheImage();
}

svoid showTheImage {
  bool first = is == null;
  is = showZoomedImage_centered(is, img, 2);
  if (first) {
    disableImageSurfaceSelector(is);
    
    // animate if idle
    awtEvery(is, 1000, r {
      if (!aiMode && isInForeground(is) && !mouseInFrame(is))
        nextImage();
    });
    
    // show current image occasionally when AI is running
    awtEvery(is, 1000/fps, r {
      if (aiMode) showTheImage();
    });
  }
}

// AI stuff

sclass Game implements GameForAI {
  int points, step, halfTimeScore;
  S submitted;
  Throwable error;
  
  public bool compareSolutions(S a, S b) {
    ret eq(a, b);
  }
  
  public S submit(S text) {
    if (submitted != null) fail("No multi-submit please");
    submitted = unnull(text);
    bool correct = compareSolutions(submitted, solution);
    // print("p=" + p + ", solution=" + solution + ", correct=" + correct);
    if (correct) {
      ++points;
      if (!alwaysNewImage) nextImage();
    }
    ret solution;
  }
}

static Game scoreAI(final AI ai, O onScore) {
  aiMode = true;
  final long start = sysNow();
  try {
    final new Game game;
    setOpt(ai, +game);
    halfTime = rounds/2;
    while (game.step < rounds) {
      if (game.step == halfTime) game.halfTimeScore = game.points;
      ++game.step;
      ++ai.steps;
      game.submitted = null;
      int points = game.points;
      RGBImage image = img;
      try {
        setOpt(ai, +image);
        ai.go();
      } catch e {
        if (game.error == null) { // print first error to console
          showConsole();
          printStackTrace(e);
        }
        game.error = e;
      } finally {
        setOpt(ai, image := null);
      }
      if (showBlunderWindow && points == game.points && hasElapsed(isWrongLast, 1000/blunderFPS)) {
        isWrongLast = sysNow();
        bool first = isWrong == null;
        S guess = game.submitted == null ? "-" : game.submitted;
        isWrong = showImage(isWrong, "Last Blunder: " + guess, image);
        if (first) {
          setFrameWidth(isWrong, 230);
          moveToTopRightCorner(isWrong);
          moveFrameDown(isWrong, 100);
        }
      }
      pcallF(onScore, game);
      if (alwaysNewImage) nextImage();
    }
    print("AI " + shortClassName(ai) + " points after " + rounds + " rounds: " + game.points);
    ai.done();
    // We consider the game solved when an AI scores 100% in second half
    if (game.points-game.halfTimeScore >= rounds-halfTime) thread {
      titleStatus(is, "Solved!");
      showAnimationInTopLeftCorner(#1004373, game.points + " of " + rounds + " points!!", 3.0);
      winner = structure(ai);
      save("winner");
    }
    ret game;
  } finally {
    aiMode = false;
    awt {
      lblTiming.setText(formatDouble(toSeconds(sysNow()-start), 1) + " s");
      nextImage();
    }
  }
}

static AI getAI(Class<? extends AI> c) {
  AI ai = ais.get(c);
  if (ai == null) ais.put(c, ai = nu(c));
  ret ai;
}

// onScore: voidfunc(Game)
static Game testAI(Class<? extends AI> c, O onScore) {
  ret scoreAI(getAI(c), onScore);
}

svoid userSaid(S text) {
  print("User said: " + text);
  ++userGame.step;
  userGame.submitted = null;
  userGame.submit(text);
  lblScore.setText(print("Your score: " + userGame.points + " of " + userGame.step));
  tfSolution.selectAll();
  if (alwaysNewImage) nextImage();
}

svoid showWinnerCode {
  if (winner == null) load("winner");
  if (winner == null) messageBox("No winner yet");
  else showWrappedText("Winner Code - " + programTitle(), winner);
}