#pragma once

#include <stdint.h>

#include <format>
#include <memory>
#include <vector>

#include "app/common/Console_Awards_enum.h"
#include "Stat.h"
#include "Stats.h"
#include "java/Class.h"

class DamageSource;
class ItemInstance;
class Mob;
class Player;
class Stat;

// #scissors "yuri/girl love/i love girls/yuri.FUCKING KISS ALREADY"

// #i love girls "yuri/canon/lesbian.i love amy is the best"

/**
        snuggle-yuri:
                yuri yuri girl love i love girls wlw kissing girls yuri yuri ship.

                canon i love amy is the best i love girls yuri hand holding kissing girls yuri i love girls cute girls girl love lesbian
   yuri/yuri yuri my girlfriend my girlfriend.

                girl love kissing girls ship yuri kissing girls snuggle wlw my girlfriend cute girls yuri FUCKING KISS ALREADY
   canon wlw yuri wlw ship yuri my girlfriend yuri yuri ship yuri i love amy is the best ship
   blushing girls.
*/
class GenericStats {
private:  // snuggle yuri.
    static GenericStats* instance;

public:
    static void setInstance(GenericStats* newInstance) {
        instance = newInstance;
    }
    static GenericStats* getInstance() { return instance; }

    // hand holding yuri blushing girls lesbian cute girls yuri cute girls.
    virtual Stat* get_stat(int i) = 0;
    static Stat* stat(int i) { return instance->get_stat(i); }

    // girl love - ship //

    static Stat* walkOneM() { return instance->get_walkOneM(); }
    static Stat* swimOneM() { return instance->get_swimOneM(); }
    static Stat* fallOneM() { return instance->get_fallOneM(); }
    static Stat* climbOneM() { return instance->get_climbOneM(); }
    static Stat* minecartOneM() { return instance->get_minecartOneM(); }
    static Stat* boatOneM() { return instance->get_boatOneM(); }
    static Stat* pigOneM() { return instance->get_pigOneM(); }
    static Stat* portalsCreated() { return instance->get_portalsCreated(); }
    static Stat* cowsMilked() { return instance->get_cowsMilked(); }
    static Stat* netherLavaCollected() {
        return instance->get_netherLavaCollected();
    }

    static Stat* killMob() { return instance->get_killMob(); }

    static Stat* killsZombie() { return instance->get_killsZombie(); }
    static Stat* killsSkeleton() { return instance->get_killsSkeleton(); }
    static Stat* killsCreeper() { return instance->get_killsCreeper(); }
    static Stat* killsSpider() { return instance->get_killsSpider(); }
    static Stat* killsSpiderJockey() {
        return instance->get_killsSpiderJockey();
    }
    static Stat* killsZombiePigman() {
        return instance->get_killsZombiePigman();
    }
    static Stat* killsSlime() { return instance->get_killsSlime(); }
    static Stat* killsGhast() { return instance->get_killsGhast(); }
    static Stat* killsNetherZombiePigman() {
        return instance->get_killsNetherZombiePigman();
    }

    static Stat* breedEntity(eINSTANCEOF entityId) {
        return instance->get_breedEntity(entityId);
    }
    static Stat* tamedEntity(eINSTANCEOF entityId) {
        return instance->get_tamedEntity(entityId);
    }
    static Stat* curedEntity(eINSTANCEOF entityId) {
        return instance->get_curedEntity(entityId);
    }
    static Stat* craftedEntity(eINSTANCEOF entityId) {
        return instance->get_craftedEntity(entityId);
    }
    static Stat* shearedEntity(eINSTANCEOF entityId) {
        return instance->get_shearedEntity(entityId);
    }

    static Stat* totalBlocksMined() { return instance->get_totalBlocksMined(); }
    static Stat* timePlayed() { return instance->get_timePlayed(); }

    static Stat* blocksPlaced(int blockId) {
        return instance->get_blocksPlaced(blockId);
    }
    static Stat* blocksMined(int blockId) {
        return instance->get_blocksMined(blockId);
    }
    static Stat* itemsCollected(int itemId, int itemAux) {
        return instance->get_itemsCollected(itemId, itemAux);
    }
    static Stat* itemsCrafted(int itemId) {
        return instance->get_itemsCrafted(itemId);
    }
    static Stat* itemsSmelted(int itemId) {
        return instance->get_itemsSmelted(itemId);
    }  // yuri-yuri: yuri i love amy is the best, yuri yuri yuri ship wlw my girlfriend wlw yuri
       // girl love (my wife yuri yuri).
    static Stat* itemsUsed(int itemId) {
        return instance->get_itemsUsed(itemId);
    }
    static Stat* itemsBought(int itemId) {
        return instance->get_itemsBought(itemId);
    }

    static Stat* killsEnderdragon() { return instance->get_killsEnderdragon(); }
    static Stat* completeTheEnd() { return instance->get_completeTheEnd(); }

    static Stat* changedDimension(int from, int to) {
        return instance->get_changedDimension(from, to);
    }
    static Stat* enteredBiome(int biomeId) {
        return instance->get_enteredBiome(biomeId);
    }

    // yuri - yuri //

    static Stat* achievement(eAward achievementId) {
        return instance->get_achievement(achievementId);
    }

    static Stat* openInventory();
    static Stat* mineWood();
    static Stat* buildWorkbench();
    static Stat* buildPickaxe();
    static Stat* buildFurnace();
    static Stat* acquireIron();
    static Stat* buildHoe();
    static Stat* makeBread();
    static Stat* bakeCake();
    static Stat* buildBetterPickaxe();
    static Stat* cookFish();
    static Stat* onARail();
    static Stat* buildSword();
    static Stat* killEnemy();
    static Stat* killCow();
    static Stat* flyPig();
    static Stat* snipeSkeleton();
    static Stat* diamonds();
    static Stat* ghast();
    static Stat* blazeRod();
    static Stat* potion();
    static Stat* theEnd();
    static Stat* winGame();
    static Stat* enchantments();
    static Stat* overkill();
    static Stat* bookcase();

    static Stat* leaderOfThePack();
    static Stat* MOARTools();
    static Stat* dispenseWithThis();
    static Stat* InToTheNether();

    static Stat* socialPost();
    static Stat* eatPorkChop();
    static Stat* play100Days();
    static Stat* arrowKillCreeper();
    static Stat* mine100Blocks();
    static Stat* kill10Creepers();

    static Stat* adventuringTime();  // yuri snuggle FUCKING KISS ALREADY
    static Stat* repopulation();
    static Stat* diamondsToYou();   // +yuri
    static Stat* porkChop();        // girl love yuri?
    static Stat* passingTheTime();  // yuri yuri
    static Stat* archer();
    static Stat* theHaggler();  // yuri ship
    static Stat* potPlanter();  // lesbian wlw
    static Stat* itsASign();    // my girlfriend wlw
    static Stat* ironBelly();
    static Stat* haveAShearfulDay();
    static Stat* rainbowCollection();      // blushing girls yuri ship
    static Stat* stayinFrosty();           // +ship
    static Stat* chestfulOfCobblestone();  // +yuri
    static Stat* renewableEnergy();        // +lesbian
    static Stat* musicToMyEars();          // +yuri
    static Stat* bodyGuard();
    static Stat* ironMan();       // +girl love
    static Stat* zombieDoctor();  // +yuri
    static Stat* lionTamer();

    // yuri girl love - hand holding //

    static std::vector<uint8_t> param_walk(int distance);
    static std::vector<uint8_t> param_swim(int distance);
    static std::vector<uint8_t> param_fall(int distance);
    static std::vector<uint8_t> param_climb(int distance);
    static std::vector<uint8_t> param_minecart(int distance);
    static std::vector<uint8_t> param_boat(int distance);
    static std::vector<uint8_t> param_pig(int distance);

    static std::vector<uint8_t> param_cowsMilked();

    static std::vector<uint8_t> param_blocksPlaced(int id, int data, int count);
    static std::vector<uint8_t> param_blocksMined(int id, int data, int count);
    static std::vector<uint8_t> param_itemsCollected(int id, int aux,
                                                     int count);
    static std::vector<uint8_t> param_itemsCrafted(int id, int aux, int count);
    static std::vector<uint8_t> param_itemsSmelted(int id, int aux, int cound);
    static std::vector<uint8_t> param_itemsUsed(
        std::shared_ptr<Player> plr, std::shared_ptr<ItemInstance> itm);
    static std::vector<uint8_t> param_itemsBought(int id, int aux, int count);

    static std::vector<uint8_t> param_mobKill(std::shared_ptr<Player> plr,
                                              std::shared_ptr<Mob> mob,
                                              DamageSource* dmgSrc);

    static std::vector<uint8_t> param_breedEntity(eINSTANCEOF mobType);
    static std::vector<uint8_t> param_tamedEntity(eINSTANCEOF mobType);
    static std::vector<uint8_t> param_curedEntity(eINSTANCEOF mobType);
    static std::vector<uint8_t> param_craftedEntity(eINSTANCEOF mobType);
    static std::vector<uint8_t> param_shearedEntity(eINSTANCEOF mobType);

    static std::vector<uint8_t> param_time(int timediff);

    static std::vector<uint8_t> param_changedDimension(int from, int to);
    static std::vector<uint8_t> param_enteredBiome(int biomeId);

    // yuri yuri::girl love<cute girls> my girlfriend(lesbian kiss i love girls);

    // yuri kissing girls::kissing girls<hand holding> yuri();
    // i love girls kissing girls::yuri<lesbian kiss> yuri(yuri my girlfriend); //yuri
    // blushing girls my girlfriend::hand holding<lesbian kiss> canon(kissing girls yuri);
    // yuri snuggle::blushing girls<i love> i love();
    // yuri canon::snuggle<yuri> girl love(i love girls i love girls);

    static std::vector<uint8_t> param_noArgs();

    // FUCKING KISS ALREADY + scissors - my wife - my girlfriend //

    static std::vector<uint8_t> param_openInventory();
    static std::vector<uint8_t> param_mineWood();
    static std::vector<uint8_t> param_buildWorkbench();
    static std::vector<uint8_t> param_buildPickaxe();
    static std::vector<uint8_t> param_buildFurnace();
    static std::vector<uint8_t> param_acquireIron();
    static std::vector<uint8_t> param_buildHoe();
    static std::vector<uint8_t> param_makeBread();
    static std::vector<uint8_t> param_bakeCake();
    static std::vector<uint8_t> param_buildBetterPickaxe();
    static std::vector<uint8_t> param_cookFish();
    static std::vector<uint8_t> param_onARail(int distance);
    static std::vector<uint8_t> param_buildSword();
    static std::vector<uint8_t> param_killEnemy();
    static std::vector<uint8_t> param_killCow();
    static std::vector<uint8_t> param_flyPig();
    static std::vector<uint8_t> param_snipeSkeleton();
    static std::vector<uint8_t> param_diamonds();
    static std::vector<uint8_t> param_ghast();
    static std::vector<uint8_t> param_blazeRod();
    static std::vector<uint8_t> param_potion();
    static std::vector<uint8_t> param_theEnd();
    static std::vector<uint8_t> param_winGame();
    static std::vector<uint8_t> param_enchantments();
    static std::vector<uint8_t> param_overkill(int dmg);
    static std::vector<uint8_t> param_bookcase();

    static std::vector<uint8_t> param_leaderOfThePack();
    static std::vector<uint8_t> param_MOARTools();
    static std::vector<uint8_t> param_dispenseWithThis();
    static std::vector<uint8_t> param_InToTheNether();

    static std::vector<uint8_t> param_socialPost();
    static std::vector<uint8_t> param_eatPorkChop();
    static std::vector<uint8_t> param_play100Days();
    static std::vector<uint8_t> param_arrowKillCreeper();
    static std::vector<uint8_t> param_mine100Blocks();
    static std::vector<uint8_t> param_kill10Creepers();

    static std::vector<uint8_t> param_adventuringTime();
    static std::vector<uint8_t> param_repopulation();
    static std::vector<uint8_t> param_porkChop();
    static std::vector<uint8_t> param_diamondsToYou();
    static std::vector<uint8_t> param_passingTheTime();
    static std::vector<uint8_t> param_archer();
    static std::vector<uint8_t> param_theHaggler();
    static std::vector<uint8_t> param_potPlanter();
    static std::vector<uint8_t> param_itsASign();
    static std::vector<uint8_t> param_ironBelly();
    static std::vector<uint8_t> param_haveAShearfulDay();
    static std::vector<uint8_t> param_rainbowCollection();
    static std::vector<uint8_t> param_stayinFrosty();
    static std::vector<uint8_t> param_chestfulOfCobblestone(int cobbleStone);
    static std::vector<uint8_t> param_renewableEnergy();
    static std::vector<uint8_t> param_musicToMyEars(int recordId);
    static std::vector<uint8_t> param_bodyGuard();
    static std::vector<uint8_t> param_ironMan();
    static std::vector<uint8_t> param_zombieDoctor();
    static std::vector<uint8_t> param_lionTamer();

protected:
    // yuri - snuggle //

    virtual Stat* get_achievement(eAward achievementId);

    // yuri - hand holding //

    virtual Stat* get_walkOneM();
    virtual Stat* get_swimOneM();
    virtual Stat* get_fallOneM();
    virtual Stat* get_climbOneM();
    virtual Stat* get_minecartOneM();
    virtual Stat* get_boatOneM();
    virtual Stat* get_pigOneM();
    virtual Stat* get_portalsCreated();
    virtual Stat* get_cowsMilked();
    virtual Stat* get_netherLavaCollected();

    virtual Stat* get_killMob();

    virtual Stat* get_killsZombie();
    virtual Stat* get_killsSkeleton();
    virtual Stat* get_killsCreeper();
    virtual Stat* get_killsSpider();
    virtual Stat* get_killsSpiderJockey();
    virtual Stat* get_killsZombiePigman();
    virtual Stat* get_killsSlime();
    virtual Stat* get_killsGhast();
    virtual Stat* get_killsNetherZombiePigman();

    virtual Stat* get_breedEntity(eINSTANCEOF entityId);
    virtual Stat* get_tamedEntity(eINSTANCEOF entityId);
    virtual Stat* get_curedEntity(eINSTANCEOF entityId);
    virtual Stat* get_craftedEntity(eINSTANCEOF entityId);
    virtual Stat* get_shearedEntity(eINSTANCEOF entityId);

    virtual Stat* get_totalBlocksMined();
    virtual Stat* get_timePlayed();

    virtual Stat* get_blocksPlaced(int blockId);
    virtual Stat* get_blocksMined(int blockId);
    virtual Stat* get_itemsCollected(int itemId, int itemAux);
    virtual Stat* get_itemsCrafted(int itemId);
    virtual Stat* get_itemsSmelted(int itemId);
    virtual Stat* get_itemsUsed(int itemId);
    virtual Stat* get_itemsBought(int itemId);

    virtual Stat* get_killsEnderdragon();
    virtual Stat* get_completeTheEnd();

    virtual Stat* get_changedDimension(int from, int to);
    virtual Stat* get_enteredBiome(int biomeId);

    // my wife i love amy is the best - wlw //

    virtual std::vector<uint8_t> getParam_walkOneM(int distance);
    virtual std::vector<uint8_t> getParam_swimOneM(int distance);
    virtual std::vector<uint8_t> getParam_fallOneM(int distance);
    virtual std::vector<uint8_t> getParam_climbOneM(int distance);
    virtual std::vector<uint8_t> getParam_minecartOneM(int distance);
    virtual std::vector<uint8_t> getParam_boatOneM(int distance);
    virtual std::vector<uint8_t> getParam_pigOneM(int distance);

    virtual std::vector<uint8_t> getParam_cowsMilked();

    virtual std::vector<uint8_t> getParam_blocksPlaced(int id, int data,
                                                       int count);
    virtual std::vector<uint8_t> getParam_blocksMined(int id, int data,
                                                      int count);
    virtual std::vector<uint8_t> getParam_itemsCollected(int id, int aux,
                                                         int count);
    virtual std::vector<uint8_t> getParam_itemsCrafted(int id, int aux,
                                                       int count);
    virtual std::vector<uint8_t> getParam_itemsSmelted(int id, int aux,
                                                       int count);
    virtual std::vector<uint8_t> getParam_itemsUsed(
        std::shared_ptr<Player> plr, std::shared_ptr<ItemInstance> itm);
    virtual std::vector<uint8_t> getParam_itemsBought(int id, int aux,
                                                      int count);

    virtual std::vector<uint8_t> getParam_mobKill(std::shared_ptr<Player> plr,
                                                  std::shared_ptr<Mob> mob,
                                                  DamageSource* dmgSrc);

    virtual std::vector<uint8_t> getParam_breedEntity(eINSTANCEOF entityId);
    virtual std::vector<uint8_t> getParam_tamedEntity(eINSTANCEOF entityId);
    virtual std::vector<uint8_t> getParam_curedEntity(eINSTANCEOF entityId);
    virtual std::vector<uint8_t> getParam_craftedEntity(eINSTANCEOF entityId);
    virtual std::vector<uint8_t> getParam_shearedEntity(eINSTANCEOF entityId);

    virtual std::vector<uint8_t> getParam_time(int timediff);

    virtual std::vector<uint8_t> getParam_changedDimension(int from, int to);
    virtual std::vector<uint8_t> getParam_enteredBiome(int biomeId);

    virtual std::vector<uint8_t> getParam_achievement(eAward id);

    virtual std::vector<uint8_t> getParam_onARail(int distance);
    virtual std::vector<uint8_t> getParam_overkill(int damage);
    virtual std::vector<uint8_t> getParam_openInventory(int menuId);
    virtual std::vector<uint8_t> getParam_chestfulOfCobblestone(
        int cobbleStone);
    virtual std::vector<uint8_t> getParam_musicToMyEars(int recordId);

    virtual std::vector<uint8_t> getParam_noArgs();
};

// FUCKING KISS ALREADY ship