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

sinterface GameForAI {
  int round(); // starting from 1
  double submit(Submission data); // returns score (0-100)
}

abstract sclass AI {
  // stuff you get
  
  GameForAI game;
  RGBImage image;
  bool visualize = true;
  
  RGBImage image() { ret image; }
  int w() { ret image.w(); }
  int h() { ret image.h(); }
  int round() { ret game.round(); }
  double submit(Submission data) { ret game.submit(data); }
  <A extends AI> A initSubAI(A ai) { setOptAll(ai, +game, +image); ret ai; }

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

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

static int rounds = 1000;
static double targetScore = 99.0; // stop when this score is reached
static int fps = 50;
sS gameTitle;
sS newImageText = "New Image";
sS instruction = "Reproduce this image:";
sS aiTitle = "AI";
sbool showConsoleOnError;
static double reproZoom = 2;
sbool showTheImage = true, showRepro = true;
static int maxImageSize = 128; // width or height
sbool mixReproWithImage = true;

static int w, h;
static new UserGame userGame;
static int halfTime;
static ImageSurface is, isUser, isRepro;
static S imageID;
static RGBImage img;
static BufferedImage fullSizeImage;
static new HashMap<Rect, Int> words;
static L<Rect> solution;
volatile sbool aiMode;
static JLabel lblScore, lblTiming, lblInstruction, lblImageName;
static new HashMap<Class, AI> ais;
static S winner;
static JCheckBox keepRunning;
static L<JButton> aiButtons;
static Game game;

svoid pGame {
  substance();
  swing {
    thread { loadBinarySnippet(#1004373); } // preload applause animation
    lblInstruction = jcenteredBoldLabel(instruction);
    lblScore = jcenteredBoldLabel();
    nextImage();
    addToWindowTop(is, withMargin(lblInstruction));
    addToWindow(is, withMargin(lblScore));
    addToWindow(is, withMargin(lblImageName = jcenteredlabel()));
    
    // add AI bjuttons
    aiButtons = ll();
    for (final Class c : myNonAbstractClassesImplementing(AI)) {
      final S name = shortClassName(c);
      final JButton btn = jbutton(name);
      final Runnable go = r {
        if (aiMode) ret;
        setText(btn, name + " Running...");
        final Runnable again = this;
        thread {
          /*game =*/ testAI(c, voidfunc(Game game) {
            if (!(game.step >= rounds || (game.step % 10) == 0)) ret;
            S text = name + " scored " + formatScore(game.score) + " in " + n(game.step, "round");
            if (game.error != null)
              text += " - ERROR: " + game.error;
            setText_noWait_sync(btn, text);
          });
          if (isChecked(keepRunning)) again.run();
        }
      };
      onClick(btn, r { if (aiMode) setChecked(keepRunning, false); else go.run(); });
      aiButtons.add(btn);
      addToWindow(is, withMargin(btn));
    }
    
    addToWindow(is, lblTiming = jCenteredLabel(;
    titlePopupMenuItem(is, "Show Winner Code", f showBestCode);
    titlePopupMenuItem(is, "Restart AIs", r { restartAIs() });
    titlePopupMenuItem(is, "Diff", r {
      setImage(subtractRGBImages(img, renderImage(game.best!)))
    });
    addToWindow(is, withMargin(jRightAlignedLine(keepRunning = jcheckbox("Keep AI Running", true))));
    addToWindow(is, withMargin(jbutton("Restart AIs", r { clearMapWithCleanUp(ais); })));
    addToWindow(is, withMargin(jbutton(newImageText, r {
      nextImage();
      setImage(main.img);
    })));
    addToWindow(is, withMargin(jbutton("Load image...", r {
      frameTitle("Load image", selectSnippetID_v1(voidfunc(S imageID) {
        loadImageSnippet(imageID);
      }));
    })));
    addToWindow(is, withMargin(jbutton("Scale down", f scaleDown)));
    addToWindow(is, withMargin(jbutton("Random image", r-thread {
      loadImageSnippet(randomImageServerID());
    })));

    packFrame(is);
    setFrameWidth(is, 500);
    centerTopFrame(is);
    hideConsole();
  }
}

svoid nextImage {
  main.img = makeImage();
  if (aiMode) ret; // occasional updates only when AI is running
  showTheImage();
}

svoid showTheImage {
  w = img.w();
  h = img.h();
  
  if (!showTheImage) ret;
  bool first = is == null;
  is = showZoomedImage_centered(is, img, 1);
    
  if (first) {
    if (gameTitle == null) gameTitle = programTitle();
    setFrameTitle(is, gameTitle);

    disableImageSurfaceSelector(is);
    
    isUser = new ImageSurface(newBufferedImage(w, h, Color.white));
    JComponent form = cast callOptMC('makeTheForm, userGame); // make form for user participation
    
    if (form != null) {
      addToWindow(is, withTitle("Your Reproduction:", jscroll_centered(isUser)));
      addToWindow(is, form);
    }
    
    // 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 {
  volatile int step;
  int rounds = main.rounds;
  new Best<Submission> best;
  RGBImage bestImage;
  double score;
  Submission submitted; // what was submitted in this round
  Throwable error;
  volatile bool cancelled;
  
  public int round() { ret step; }
  int rounds() { ret rounds; }
  double percentScore() { ret score; }
  S bestCode() { ret struct(best!); }
  
  public double submit(Submission data) {
    if (data == null) ret 0;
    if (submitted != null) fail("No multi-submit please");
    submitted = data;
    RGBImage image = renderImage(data);
    double score = scoreImage(image);
    if (best.put(data, score)) {
      bestImage = image;
      this.score = best.score;
    }
    ret score;
  }
}

Game > UserGame {
  public double submit(Submission data) {
    submitted = null;
    double score = super.submit(data);
    RGBImage image = renderImage(data);
    isUser.setImage(image);
    lblScore.setText("Current score: " + formatScore(score)
      + " / Best: " + formatScore(userGame.score));
    ret score;
  }
}

static S formatScore(double score) {
  ret formatDouble(score, 2) + " %";
}

svoid initAI(AI ai, GameForAI game) {
  setOpt(ai, +game);
}

static Game scoreAI(final AI ai) {
  ret scoreAI(ai, null);
}

static Game scoreAI(final AI ai, O onScore) {
  aiMode = true;
  final long start = sysNow();
  try {
    final new Game game;
    initAI(ai, game);
    halfTime = rounds/2;
    game.step = 0;
    main.game = game;
    while (game.step < rounds && !game.cancelled) {
      ++game.step;
      game.submitted = null;
      double score = game.score;
      RGBImage image = img;
      try {
        setOpt(ai, +image);
        ai.go();
      } catch e {
        if (game.error == null) { // print first error to console
          if (showConsoleOnError) showConsole();
          printStackTrace(e);
        }
        game.error = e;
      } finally {
        setOpt(ai, image := null);
      }
      if (game.score > score && showRepro) {
        bool first = isRepro == null;
        S title = dropSpaces(formatScore(game.score)) + " - " + aiTitle;
        BufferedImage reproImg = renderWithHints(game.best!);
        if (mixReproWithImage)
          reproImg = blendBufferedImages(img.getBufferedImage(), reproImg);
        isRepro = showZoomedImage_centered(isRepro, title, reproImg, reproZoom);
        if (first) {
          //coActivateAllMyFrames();
          moveToTopRightCorner(isRepro);
          enlargeFrameLeftAndBottom(isRepro, 100, 100);
        }
      }
      pcallF(onScore, game);
      //if (alwaysNewImage) nextImage();
    }
    ai.done();
    
    // TODO: winner saving
    /*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;
      setText(lblTiming, formatDouble(toSeconds(sysNow()-start), 1) + " s");
  }
}

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 showBestCode {
  Submission s = game.best!;
  showWrappedText("Best code (" + formatScore(game.best.score()) + ")", structure(s));
}

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

static double scoreImage(RGBImage image) {
  ret 100*(1.0-rgbDistance(image, img));
}

svoid restartAIs {
  clearMapWithCleanUp(ais);
  // whatever I do, it doesn't get cancelled, haha
  //if (game != null) game.cancelled = true;
}

svoid setInstruction(S s) {
  setText(lblInstruction, instruction = s);
}

svoid setImage(final RGBImage img) {
  swing {
    main.img = img;
    showTheImage();
    restartAIs();
  }
}

svoid scaleDown() {
  setImage(rgbScale(main.img, 0.5));
}

svoid loadImageSnippet(S id) {
  imageID = id;
  BufferedImage img = changeTransparencyToWhiteBackground(loadImage2(id));
  fullSizeImage = img;
  img = scaleBufferedImageToMaxWidthOrHeight(maxImageSize, img);
  setImage(RGBImage(img));
  setText(lblImageName, snippetWithTitle(id));
}

// We now render in BufferedImage
static RGBImage renderImage(Submission s) {
  ret new RGBImage(renderImage1(s));
}