import { MapInfo } from "osu-droid";

// MD5 hash is also supported
const beatmapInfo = await MapInfo.getInformation({ beatmapID: 901854 });

if (!beatmapInfo.title) {
    return console.log("Beatmap not found");
}

// Parsed beatmap can be accessed via the `map` field
// Note that the parsed beatmap will be cloned every time this is called. This allows caching of the original instance when needed
console.log(beatmapInfo.map);

import { readFile } from "fs";
import { Parser } from "osu-droid";

readFile("path/to/file.osu", { encoding: "utf-8" }, (err, data) => {
    if (err) throw err;

    const parser = new Parser().parse(data);

    // Parsed beatmap can be accessed via the `map` field
    console.log(parser.map);
});

import { DroidStarRating, MapInfo, MapStars, OsuStarRating } from "osu-droid";

const beatmapInfo = await MapInfo.getInformation({ beatmapID: 901854 });

if (!beatmapInfo.title) {
    return console.log("Beatmap not found");
}

// Calculate osu!droid difficulty
const droidRating = new DroidStarRating().calculate({
    map: beatmapInfo.map,
});

console.log(droidRating);

// Calculate osu!standard difficulty
const osuRating = new OsuStarRating().calculate({
    map: beatmapInfo.map,
});

console.log(osuRating);

// Calculate both osu!droid and osu!standard difficulty
const rating = new MapStars().calculate({
    map: beatmapInfo.map,
});

// osu!droid difficulty
console.log(rating.droidStars);
// osu!standard difficulty
console.log(rating.pcStars);

import { MapInfo, MapStars, MapStats, ModUtil } from "osu-droid";

const beatmapInfo = await MapInfo.getInformation({ beatmapID: 901854 });

if (!beatmapInfo.title) {
    return console.log("Beatmap not found");
}

const mods = ModUtil.pcStringToMods("HDHR");

const stats = new MapStats({
    ar: 9,
    isForceAR: true,
    speedMultiplier: 1.5,
});

// Also available for `DroidStarRating` and `OsuStarRating`
const rating = new MapStars().calculate({
    map: beatmapInfo.map,
    mods: mods,
    stats: stats,
});

// osu!droid difficulty
console.log(rating.droidStars);
// osu!standard difficulty
console.log(rating.pcStars);

import { MapInfo, OsuStarRating } from "osu-droid";

const beatmapInfo = await MapInfo.getInformation({ beatmapID: 901854 });

if (!beatmapInfo.title) {
    return console.log("Beatmap not found");
}

const rating = new OsuStarRating().calculate({
    map: beatmapInfo.map,
});

// Generate a graph without a background and black graph color
console.log(await rating.getStrainChart());

// Generate a graph using the beatmap set's banner and black graph color
// For usage without osu! API, use `<Parser>.beatmapsetId`
console.log(await rating.getStrainChart(beatmapInfo.beatmapsetID));

// Generate a graph using the beatmap set's banner and a specific graph color
console.log(await rating.getStrainChart(beatmapInfo.beatmapsetID, "#fcba03"));

import {
    DroidPerformanceCalculator,
    MapInfo,
    MapStars,
    OsuPerformanceCalculator,
} from "osu-droid";

const beatmapInfo = await MapInfo.getInformation({ beatmapID: 901854 });

if (!beatmapInfo.title) {
    return console.log("Beatmap not found");
}

const rating = new MapStars().calculate({
    map: beatmapInfo.map,
});

// osu!droid performance
const droidPerformance = new DroidPerformanceCalculator().calculate({
    stars: rating.droidStars,
});
console.log(droidPerformance);

// osu!standard performance
const osuPerformance = new OsuPerformanceCalculator().calculate({
    stars: rating.pcStars,
});
console.log(osuPerformance);

import {
    Accuracy,
    MapInfo,
    MapStats,
    OsuPerformanceCalculator,
    OsuStarRating,
} from "osu-droid";

const beatmapInfo = await MapInfo.getInformation({ beatmapID: 901854 });

if (!beatmapInfo.title) {
    return console.log("Beatmap not found");
}

const rating = new OsuStarRating().calculate({
    map: beatmapInfo.map,
});

const accuracy = new Accuracy({
    // Specify your misses here
    nmiss: 1,

    // The module provides a convenient way to specify accuracy based on the data that you have
    // Remove the codes below as you see fit

    // If you have hit data (amount of 300s, 100s, and 50s)
    n300: 1000,
    n100: 0,
    n50: 0,

    // If you have accuracy percentage
    // While this method is more convenient to use, the amount of 300s, 100s, and 50s will be estimated
    // This will lead to values being off when calculating for specific accuracies
    percent: 100,
    nobjects: beatmapInfo.objects,
});

const stats = new MapStats({
    ar: 9.5,
    isForceAR: true,
    speedMultiplier: 1.25,
});

const performance = new OsuPerformanceCalculator().calculate({
    stars: rating,
    combo: 1250,
    accPercent: accuracy,
    // The tap penalty can be properly obtained by checking a replay for three finger usage
    // However, a custom value can also be provided
    tapPenalty: 1.5,
    stats: stats,
});

console.log(performance);

import { DroidStarRating, MapInfo, MapStats, Score } from "osu-droid";

const beatmapInfo = await MapInfo.getInformation({ beatmapID: 901854 });

if (!beatmapInfo.title) {
    return console.log("Beatmap not found");
}

const score = await Score.getFromHash({
    uid: 51076,
    hash: beatmapInfo.hash,
});

if (!score.title) {
    return console.log("Score not found");
}

await score.downloadReplay();

// A `ReplayAnalyzer` instance that contains the replay
const { replay } = score;
// The data of the replay
const { data } = replay;

if (!data) {
    return console.log("Replay not found");
}

const stats = new MapStats({
    ar: data.forcedAR,
    speedMultiplier: data.speedModification,
    isForceAR: !isNaN(data.forcedAR),
    // In droid version 1.6.7 and below, there exists a bug where NC is slower than DT in a few beatmaps
    // This option checks for said condition
    oldStatistics: data.replayVersion <= 3,
});

replay.map = new DroidStarRating().calculate({
    map: beatmapInfo.map,
    mods: data.convertedMods,
    stats: stats,
});

// More data can be obtained after specifying beatmap. We can call this method again to do so
await replay.analyze();

// Check for three-finger usage
replay.checkFor3Finger();

// Check for two-hand usage
replay.checkFor2Hand();

import { DroidStarRating, MapInfo, MapStats, ReplayAnalyzer } from "osu-droid";

const beatmapInfo = await MapInfo.getInformation({ beatmapID: 901854 });

if (!beatmapInfo.title) {
    return console.log("Beatmap not found");
}

// A `ReplayAnalyzer` instance that contains the replay
const replay = await new ReplayAnalyzer({ scoreID: 12948732 }).analyze();
// The data of the replay
const { data } = replay;

if (!data) {
    return console.log("Replay not found");
}

const stats = new MapStats({
    ar: data.forcedAR,
    speedMultiplier: data.speedModification,
    isForceAR: !isNaN(data.forcedAR),
    // In droid version 1.6.7 and below, there exists a bug where NC is slower than DT in a few beatmaps
    // This option checks for said condition
    oldStatistics: data.replayVersion <= 3,
});

replay.map = new DroidStarRating().calculate({
    map: beatmapInfo.map,
    mods: data.convertedMods,
    stats: stats,
});

// More data can be obtained after specifying beatmap. We can call this method again to do so
await replay.analyze();

// Check for three-finger usage
replay.checkFor3Finger();

// Check for two-hand usage
replay.checkFor2Hand();

import { readFile } from "fs";
import { DroidStarRating, MapInfo, MapStats, ReplayAnalyzer } from "osu-droid";

readFile("path/to/file.odr", async (err, replayData) => {
    if (err) throw err;

    const beatmapInfo = await MapInfo.getInformation({ beatmapID: 901854 });

    if (!beatmapInfo.title) {
        return console.log("Beatmap not found");
    }

    // A `ReplayAnalyzer` instance that contains the replay
    const replay = new ReplayAnalyzer({ scoreID: 0 });

    replay.originalODR = replayData;

    await replay.analyze();

    // The data of the replay
    const { data } = replay;

    const stats = new MapStats({
        ar: data.forcedAR,
        speedMultiplier: data.speedModification,
        isForceAR: !isNaN(data.forcedAR),
        // In droid version 1.6.7 and below, there exists a bug where NC is slower than DT in a few beatmaps
        // This option checks for said condition
        oldStatistics: data.replayVersion <= 3,
    });

    replay.map = new DroidStarRating().calculate({
        map: beatmapInfo.map,
        mods: data.convertedMods,
        stats: stats,
    });

    // More data can be obtained after specifying beatmap. We can call this method again to do so
    await replay.analyze();

    // Check for three-finger usage
    replay.checkFor3Finger();

    // Check for two-hand usage
    replay.checkFor2Hand();
});