// Copyright (c) 2024, the R8 project authors. Please see the AUTHORS file
// for details. All rights reserved. Use of this source code is governed by a
// BSD-style license that can be found in the LICENSE file.
import chart from "./chart.js";
import dom from "./dom.js";
import url from "./url.js";

var commits = null;

const benchmarks = new Set();
const selectedBenchmarks = new Set();

const legends = new Set();
const selectedLegends = new Set();

const zoom = { left: -1, right: -1 };

function forEachBenchmark(callback) {
  for (const benchmark of benchmarks.values()) {
    callback(benchmark, selectedBenchmarks.has(benchmark));
  }
}

function forEachSelectedBenchmark(callback) {
  forEachBenchmark((benchmark, selected) => {
    if (selected) {
      callback(benchmark);
    }
  });
}

function getCommit(index, zoom) {
  return getCommits(zoom)[index];
}

function getCommitFromContext(context) {
  const elementInfo = context[0];
  var commit;
  if (elementInfo.dataset.type == "line") {
    commit = getCommit(elementInfo.dataIndex, zoom);
  } else {
    console.assert(elementInfo.dataset.type == "scatter");
    commit = getCommit(elementInfo.raw.x, zoom);
  }
  return commit;
}

function getCommitDescriptionFromContext(context) {
  const commit = getCommitFromContext(context);
  const elementInfo = context[0];
  const dataset = chart.get().data.datasets[elementInfo.datasetIndex];
  return (
    `App: ${dataset.benchmark}\n` +
    `Author: ${commit.author}\n` +
    `Submitted: ${new Date(commit.submitted * 1000).toLocaleString()}\n` +
    `Hash: ${commit.hash}\n` +
    `Index: ${commit.index}`
  );
}

function getCommits(zoom) {
  const commitsForSelectedBranch = commits.filter((commit) =>
    dom.isCommitSelected(commit),
  );
  if (zoom) {
    return commitsForSelectedBranch.slice(zoom.left, zoom.right);
  }
  return commitsForSelectedBranch;
}

function getTryCommitsByParentHash(loadedTryCommits) {
  const result = {};
  for (var i = 0; i < loadedTryCommits.length; i++) {
    const commit = loadedTryCommits[i];
    const parentHash = commit["parent_hash"];
    if (parentHash in result) {
      result[parentHash].push(commit);
    } else {
      result[parentHash] = [commit];
    }
  }
  return result;
}

function hasLegend(legend) {
  return legends.has(legend);
}

function importCommits(url, tryUrl = null) {
  const promises = [import(url, { with: { type: "json" } })];
  if (tryUrl !== null) {
    promises.push(import(tryUrl, { with: { type: "json" } }));
  }
  return Promise.all(promises).then((values) => {
    const loadedCommits = values[0].default;
    const loadedTryCommits = values.length > 1 ? values[1].default : [];
    const loadedTryCommitsByParentHash =
      getTryCommitsByParentHash(loadedTryCommits);
    // Amend the commits with their unique index.
    var mainIndex = 0;
    var releaseIndex = 0;
    const processedCommits = [];
    for (var i = loadedCommits.length - 1; i >= 0; i--) {
      const commit = loadedCommits[i];
      commit.index = commit.version ? releaseIndex++ : mainIndex++;
      processedCommits.push(commit);

      // Include the try commits for this commit on main.
      const hash = commit["hash"];
      if (hash in loadedTryCommitsByParentHash) {
        console.assert(!commit.version, "Try jobs for release not supported");
        const tryCommitsForCurrentCommit = loadedTryCommitsByParentHash[hash];
        for (var j = 0; j < tryCommitsForCurrentCommit.length; j++) {
          const tryCommitForCurrentCommit = tryCommitsForCurrentCommit[j];
          tryCommitForCurrentCommit.index = mainIndex++;
        }
        processedCommits.push(...tryCommitsForCurrentCommit);
      }
    }
    commits = processedCommits;
    return processedCommits;
  });
}

function initializeBenchmarks() {
  for (const commit of commits.values()) {
    for (const benchmark in commit.benchmarks) {
      benchmarks.add(benchmark);
    }
  }
  for (const benchmark of benchmarks.values()) {
    if (url.matches(benchmark)) {
      selectedBenchmarks.add(benchmark);
    }
  }
  if (selectedBenchmarks.size == 0) {
    const randomBenchmarkIndex = Math.floor(Math.random() * benchmarks.size);
    const randomBenchmark = Array.from(benchmarks)[randomBenchmarkIndex];
    selectedBenchmarks.add(randomBenchmark);
  }
}

function initializeLegends(legendsInfo) {
  for (var legend in legendsInfo) {
    legends.add(legend);
    if (url.contains(legend)) {
      selectedLegends.add(legend);
    }
  }
  if (selectedLegends.size == 0) {
    for (let [legend, legendInfo] of Object.entries(legendsInfo)) {
      if (legendInfo.default) {
        selectedLegends.add(legend);
      }
    }
  }
}

function initializeZoom() {
  const filteredCommits = resetZoom();
  for (const urlOption of url.values()) {
    if (urlOption.startsWith("L")) {
      var left = parseInt(urlOption.substring(1));
      if (isNaN(left)) {
        continue;
      }
      left = left >= 0 ? left : filteredCommits.length + left;
      if (left < 0) {
        zoom.left = 0;
      } else if (left >= filteredCommits.length) {
        zoom.left = filteredCommits.length - 1;
      } else {
        zoom.left = left;
      }
    }
  }
}

function resetZoom() {
  const filteredCommits = getCommits(null);
  zoom.left = Math.max(0, filteredCommits.length - 75);
  zoom.right = filteredCommits.length;
  return filteredCommits;
}

function handleKeyDownEvent(e, callback) {
  if (selectedBenchmarks.size != 1) {
    return;
  }
  const [selectedBenchmark] = selectedBenchmarks;
  var benchmarkToSelect = null;
  var previousBenchmark = null;
  for (const benchmark of benchmarks.values()) {
    if (previousBenchmark != null) {
      if (e.key == "ArrowLeft" && benchmark == selectedBenchmark) {
        benchmarkToSelect = previousBenchmark;
        break;
      } else if (
        e.key === "ArrowRight" &&
        previousBenchmark == selectedBenchmark
      ) {
        benchmarkToSelect = benchmark;
        break;
      }
    }
    previousBenchmark = benchmark;
  }
  if (benchmarkToSelect != null) {
    selectedBenchmarks.clear();
    selectedBenchmarks.add(benchmarkToSelect);
    document.getElementById(selectedBenchmark).checked = false;
    document.getElementById(benchmarkToSelect).checked = true;
    callback();
  }
}

function isLegendSelected(legend) {
  return selectedLegends.has(legend);
}

export default {
  benchmarks: benchmarks,
  commits: getCommits,
  legends: legends,
  selectedBenchmarks: selectedBenchmarks,
  selectedLegends: selectedLegends,
  forEachBenchmark: forEachBenchmark,
  forEachSelectedBenchmark: forEachSelectedBenchmark,
  getCommit: getCommit,
  getCommitFromContext: getCommitFromContext,
  getCommitDescriptionFromContext: getCommitDescriptionFromContext,
  handleKeyDownEvent: handleKeyDownEvent,
  hasLegend: hasLegend,
  initializeBenchmarks: initializeBenchmarks,
  initializeLegends: initializeLegends,
  initializeZoom: initializeZoom,
  importCommits: importCommits,
  isLegendSelected: isLegendSelected,
  resetZoom: resetZoom,
  zoom: zoom,
};