package mage.verify;

import com.google.common.base.CharMatcher;
import com.google.gson.Gson;
import mage.MageObject;
import mage.Mana;
import mage.ObjectColor;
import mage.abilities.*;
import mage.abilities.common.*;
import mage.abilities.condition.Condition;
import mage.abilities.costs.Cost;
import mage.abilities.dynamicvalue.DynamicValue;
import mage.abilities.effects.Effect;
import mage.abilities.effects.common.ExileUntilSourceLeavesEffect;
import mage.abilities.effects.common.FightTargetsEffect;
import mage.abilities.effects.common.InfoEffect;
import mage.abilities.effects.common.counter.ProliferateEffect;
import mage.abilities.effects.keyword.ScryEffect;
import mage.abilities.hint.common.CitysBlessingHint;
import mage.abilities.hint.common.CurrentDungeonHint;
import mage.abilities.hint.common.InitiativeHint;
import mage.abilities.hint.common.MonarchHint;
import mage.abilities.keyword.*;
import mage.cards.*;
import mage.cards.decks.CardNameUtil;
import mage.cards.decks.Deck;
import mage.cards.decks.DeckCardInfo;
import mage.cards.decks.DeckCardLists;
import mage.cards.decks.importer.DeckImporter;
import mage.cards.repository.*;
import mage.choices.Choice;
import mage.client.remote.XmageURLConnection;
import mage.constants.*;
import mage.filter.Filter;
import mage.filter.predicate.Predicate;
import mage.filter.predicate.Predicates;
import mage.game.FakeGame;
import mage.game.Game;
import mage.game.command.Dungeon;
import mage.game.command.Emblem;
import mage.game.command.Plane;
import mage.game.command.emblems.EmblemOfCard;
import mage.game.draft.DraftCube;
import mage.game.permanent.token.Token;
import mage.game.permanent.token.TokenImpl;
import mage.game.permanent.token.custom.CreatureToken;
import mage.game.permanent.token.custom.XmageToken;
import mage.sets.TherosBeyondDeath;
import mage.target.Target;
import mage.target.targetpointer.TargetPointer;
import mage.tournament.cubes.CubeFromDeck;
import mage.util.CardUtil;
import mage.utils.SystemUtil;
import mage.verify.mtgjson.MtgJsonCard;
import mage.verify.mtgjson.MtgJsonService;
import mage.verify.mtgjson.MtgJsonSet;
import mage.verify.mtgjson.SpellBookCardsPage;
import mage.watchers.Watcher;
import net.java.truevfs.access.TFile;
import org.apache.log4j.Logger;
import org.junit.Assert;
import org.junit.Ignore;
import org.junit.Test;
import org.mage.plugins.card.dl.sources.ScryfallImageSupportCards;
import org.reflections.Reflections;

import java.io.File;
import java.io.IOException;
import java.lang.reflect.*;
import java.nio.charset.StandardCharsets;
import java.nio.file.*;
import java.nio.file.attribute.BasicFileAttributes;
import java.time.LocalDate;
import java.time.format.DateTimeFormatter;
import java.util.*;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.stream.Collectors;

/**
 * @author JayDi85
 */
public class VerifyCardDataTest {

    private static final Logger logger = Logger.getLogger(VerifyCardDataTest.class);

    private static String FULL_ABILITIES_CHECK_SET_CODES = ""; // check ability text due mtgjson, can use multiple sets like MAT;CMD or * for all
    private static boolean CHECK_ONLY_ABILITIES_TEXT = false; // use when checking text locally, suppresses unnecessary checks and output messages
    private static final boolean CHECK_COPYABLE_FIELDS = true; // disable for better verify test performance

    // for automated local testing support
    static {
        String val = System.getProperty("xmage.tests.verifyCheckSetCodes");
        if (val != null) {
            FULL_ABILITIES_CHECK_SET_CODES = val;
        }
        val = System.getProperty("xmage.tests.verifyCheckOnlyText");
        if (val != null) {
            CHECK_ONLY_ABILITIES_TEXT = Boolean.parseBoolean(val);
        }
    }

    private static final boolean AUTO_FIX_SAMPLE_DECKS = false; // debug only: auto-fix sample decks by test_checkSampleDecks test run

    private static final Set<String> checkedNames = new HashSet<>(); // skip already checked cards
    private static final HashMap<String, Set<String>> skipCheckLists = new HashMap<>();
    private static final Set<String> subtypesToIgnore = new HashSet<>();
    private static final String SKIP_LIST_PT = "PT";
    private static final String SKIP_LIST_LOYALTY = "LOYALTY";
    private static final String SKIP_LIST_DEFENSE = "DEFENSE";
    private static final String SKIP_LIST_COLOR = "COLOR";
    private static final String SKIP_LIST_COST = "COST";
    private static final String SKIP_LIST_SUPERTYPE = "SUPERTYPE";
    private static final String SKIP_LIST_TYPE = "TYPE";
    private static final String SKIP_LIST_SUBTYPE = "SUBTYPE";
    private static final String SKIP_LIST_NUMBER = "NUMBER";
    private static final String SKIP_LIST_RARITY = "RARITY";
    private static final String SKIP_LIST_MISSING_ABILITIES = "MISSING_ABILITIES";
    private static final String SKIP_LIST_DOUBLE_RARE = "DOUBLE_RARE";
    private static final String SKIP_LIST_UNSUPPORTED_SETS = "UNSUPPORTED_SETS";
    private static final String SKIP_LIST_SCRYFALL_DOWNLOAD_SETS = "SCRYFALL_DOWNLOAD_SETS";
    private static final String SKIP_LIST_WRONG_CARD_NUMBERS = "WRONG_CARD_NUMBERS";
    private static final String SKIP_LIST_SAMPLE_DECKS = "SAMPLE_DECKS";
    private static final List<String> evergreenKeywords = Arrays.asList(
            "flying", "lifelink", "menace", "trample", "haste", "first strike", "hexproof", "fear",
            "deathtouch", "double strike", "indestructible", "reach", "flash", "defender", "vigilance",
            "plainswalk", "islandwalk", "swampwalk", "mountainwalk", "forestwalk", "myriad", "prowess", "convoke",
            "shroud", "banding", "flanking", "horsemanship", "legendary landwalk"
    );

    private static final List<String> doubleWords = new ArrayList<>(); // for inner calc
    private static final List<String> etbTriggerPhrases = new ArrayList<>(); // for inner calc

    static {
        // numbers
        for (int i = 1; i <= 9; i++) {
            String s = CardUtil.numberToText(i).toLowerCase(Locale.ENGLISH);
            doubleWords.add(s + " " + s);
        }

        // additional checks
        doubleWords.add(" an an ");
        doubleWords.add(" a a ");
    }

    static {
        // skip lists for checks (example: unstable cards with same name may have different stats)
        // can be full set ignore list or set + cardname

        // power-toughness
        // skipListAddName(SKIP_LIST_PT, set, cardName);

        // loyalty
        // skipListAddName(SKIP_LIST_LOYALTY, set, cardName);

        // defense
        // skipListAddName(SKIP_LIST_DEFENSE, set, cardName);

        // color
        // skipListAddName(SKIP_LIST_COLOR, set, cardName);

        // cost
        // skipListAddName(SKIP_LIST_COST, set, cardName);

        // supertype
        // skipListAddName(SKIP_LIST_SUPERTYPE, set, cardName);

        // type
        // skipListAddName(SKIP_LIST_TYPE, set, cardName);
        skipListAddName(SKIP_LIST_TYPE, "UNH", "Old Fogey"); // uses summon word as a joke card
        skipListAddName(SKIP_LIST_TYPE, "UND", "Old Fogey");
        skipListAddName(SKIP_LIST_TYPE, "UST", "capital offense"); // uses "instant" instead "Instant" as a joke card

        // subtype
        // skipListAddName(SKIP_LIST_SUBTYPE, set, cardName);
        skipListAddName(SKIP_LIST_SUBTYPE, "UGL", "Miss Demeanor"); // uses multiple types as a joke card: Lady, of, Proper, Etiquette
        skipListAddName(SKIP_LIST_SUBTYPE, "UGL", "Elvish Impersonators"); // subtype is "Elves" pun
        skipListAddName(SKIP_LIST_SUBTYPE, "UND", "Elvish Impersonators");

        // number
        // skipListAddName(SKIP_LIST_NUMBER, set, cardName);

        // rarity
        // skipListAddName(SKIP_LIST_RARITY, set, cardName);
        skipListAddName(SKIP_LIST_RARITY, "CMR", "The Prismatic Piper"); // Collation is not yet set up for CMR https://www.lethe.xyz/mtg/collation/cmr.html
        skipListAddName(SKIP_LIST_RARITY, "TLE", "Teferi's Protection"); // temporary

        // missing abilities
        // skipListAddName(SKIP_LIST_MISSING_ABILITIES, set, cardName);

        // double rare cards
        // skipListAddName(SKIP_LIST_DOUBLE_RARE, set, cardName);

        // Un-supported sets (mtgjson/scryfall contains that set but xmage don't implement it)
        // Example: Non-English sets, Token sets, Archenemy Schemes, Plane-Chase Planes, etc.
        // Sets with no cards or with "Oversized" in the name are automatically skipped.
        //
        // Non-English-only sets should not be added. https://github.com/magefree/mage/pull/6190#issuecomment-582354790
        skipListAddName(SKIP_LIST_UNSUPPORTED_SETS, "4BB"); // 4th Edition Foreign black border.
        skipListAddName(SKIP_LIST_UNSUPPORTED_SETS, "FBB"); // Foreign Black Border. Not on Scryfall, but other sources use this to distinguish non-English Revised cards
        skipListAddName(SKIP_LIST_UNSUPPORTED_SETS, "PHJ"); // Hobby Japan Promos
        skipListAddName(SKIP_LIST_UNSUPPORTED_SETS, "PJJT"); // Japan Junior Tournament
        skipListAddName(SKIP_LIST_UNSUPPORTED_SETS, "PRED"); // Redemption Program
        skipListAddName(SKIP_LIST_UNSUPPORTED_SETS, "PSAL"); // Salvat 2005
        skipListAddName(SKIP_LIST_UNSUPPORTED_SETS, "PS11"); // Salvat 2011
        skipListAddName(SKIP_LIST_UNSUPPORTED_SETS, "PMPS"); // Magic Premiere Shop 2005, Japanese Basic lands
        skipListAddName(SKIP_LIST_UNSUPPORTED_SETS, "PMPS06"); // Magic Premiere Shop 2006, Japanese Basic lands
        skipListAddName(SKIP_LIST_UNSUPPORTED_SETS, "PMPS07"); // Magic Premiere Shop 2007, Japanese Basic lands
        skipListAddName(SKIP_LIST_UNSUPPORTED_SETS, "PMPS08"); // Magic Premiere Shop 2008, Japanese Basic lands
        skipListAddName(SKIP_LIST_UNSUPPORTED_SETS, "PMPS09"); // Magic Premiere Shop 2009, Japanese Basic lands
        skipListAddName(SKIP_LIST_UNSUPPORTED_SETS, "PMPS10"); // Magic Premiere Shop 2010, Japanese Basic lands
        skipListAddName(SKIP_LIST_UNSUPPORTED_SETS, "PMPS11"); // Magic Premiere Shop 2011, Japanese Basic lands
        skipListAddName(SKIP_LIST_UNSUPPORTED_SETS, "REN"); // Renaissance
        skipListAddName(SKIP_LIST_UNSUPPORTED_SETS, "RIN"); // Rinascimento
        //
        // Archenemy Schemes
        skipListAddName(SKIP_LIST_UNSUPPORTED_SETS, "OARC"); // Archenemy Schemes
        skipListAddName(SKIP_LIST_UNSUPPORTED_SETS, "OE01"); // Archenemy: Nicol Bolas Schemes
        skipListAddName(SKIP_LIST_UNSUPPORTED_SETS, "PARC"); // Promotional Schemes
        //
        // Plane-chase Planes
        skipListAddName(SKIP_LIST_UNSUPPORTED_SETS, "OHOP"); // Planechase Planes
        skipListAddName(SKIP_LIST_UNSUPPORTED_SETS, "OPC2"); // Planechase 2012 Plane
        skipListAddName(SKIP_LIST_UNSUPPORTED_SETS, "OPCA"); // Planechase Anthology Planes
        skipListAddName(SKIP_LIST_UNSUPPORTED_SETS, "PHOP"); // Promotional Planes
        //
        // Token sets TODO: implement tokens only sets
        skipListAddName(SKIP_LIST_UNSUPPORTED_SETS, "L12"); // League Tokens 2012
        skipListAddName(SKIP_LIST_UNSUPPORTED_SETS, "L13"); // League Tokens 2013
        skipListAddName(SKIP_LIST_UNSUPPORTED_SETS, "L14"); // League Tokens 2014
        skipListAddName(SKIP_LIST_UNSUPPORTED_SETS, "L15"); // League Tokens 2015
        skipListAddName(SKIP_LIST_UNSUPPORTED_SETS, "L16"); // League Tokens 2016
        skipListAddName(SKIP_LIST_UNSUPPORTED_SETS, "L17"); // League Tokens 2017
        skipListAddName(SKIP_LIST_UNSUPPORTED_SETS, "PLNY"); // 2018 Lunar New Year
        skipListAddName(SKIP_LIST_UNSUPPORTED_SETS, "F18"); // Friday Night Magic 2018
        skipListAddName(SKIP_LIST_UNSUPPORTED_SETS, "PR2"); // Magic Player Rewards 2002
        //
        // PvE sets containing non-traditional cards. These enable casual PvE battles against a "random AI"-driven opponent.
        skipListAddName(SKIP_LIST_UNSUPPORTED_SETS, "PPC1"); // M15 Prerelease Challenge
        skipListAddName(SKIP_LIST_UNSUPPORTED_SETS, "TBTH"); // Battle the Horde
        skipListAddName(SKIP_LIST_UNSUPPORTED_SETS, "TDAG"); // Defeat a God
        skipListAddName(SKIP_LIST_UNSUPPORTED_SETS, "TFTH"); // Face the Hydra
        skipListAddName(SKIP_LIST_UNSUPPORTED_SETS, "THP1"); // Theros Hero's Path
        skipListAddName(SKIP_LIST_UNSUPPORTED_SETS, "THP2"); // Born of the Gods Hero's Path
        skipListAddName(SKIP_LIST_UNSUPPORTED_SETS, "THP3"); // Journey into Nyx Hero's Path
        //
        // Other
        skipListAddName(SKIP_LIST_UNSUPPORTED_SETS, "PCEL"); // Celebration Cards
        skipListAddName(SKIP_LIST_UNSUPPORTED_SETS, "PMOA"); // Magic Online Avatar
        skipListAddName(SKIP_LIST_UNSUPPORTED_SETS, "PVAN"); // Vanguard Series
        skipListAddName(SKIP_LIST_UNSUPPORTED_SETS, "PTG"); // Ponies: The Galloping

        // wrong card numbers skip list
        skipListAddName(SKIP_LIST_WRONG_CARD_NUMBERS, "SWS"); // Star Wars
        skipListAddName(SKIP_LIST_WRONG_CARD_NUMBERS, "UND"); // un-sets don't have full implementation of card variations
        skipListAddName(SKIP_LIST_WRONG_CARD_NUMBERS, "UST"); // un-sets don't have full implementation of card variations
        skipListAddName(SKIP_LIST_WRONG_CARD_NUMBERS, "SOI", "Tamiyo's Journal"); // not all variations implemented
        skipListAddName(SKIP_LIST_WRONG_CARD_NUMBERS, "SLD", "Zndrsplt, Eye of Wisdom"); // has alternative image as second side
        skipListAddName(SKIP_LIST_WRONG_CARD_NUMBERS, "SLD", "Krark's Thumb"); // has alternative image as second side
        skipListAddName(SKIP_LIST_WRONG_CARD_NUMBERS, "SLD", "Okaun, Eye of Chaos"); // has alternative image as second side
        skipListAddName(SKIP_LIST_WRONG_CARD_NUMBERS, "SLD", "Propaganda"); // has alternative image as second side
        skipListAddName(SKIP_LIST_WRONG_CARD_NUMBERS, "SLD", "Stitch in Time"); // has alternative image as second side
        skipListAddName(SKIP_LIST_WRONG_CARD_NUMBERS, "SLD", "Zndrsplt, Eye of Wisdom"); // has alternative image as second side


        // scryfall download sets (missing from scryfall website)
        skipListAddName(SKIP_LIST_SCRYFALL_DOWNLOAD_SETS, "SWS"); // Star Wars

        // sample decks checking - some decks can contains unimplemented cards, so ignore it
        // file name must be related to sample-decks folder
        // for linux/windows build system use paths constructor
        skipListAddName(SKIP_LIST_SAMPLE_DECKS, Paths.get("Jumpstart", "jumpstart_custom.txt").toString()); // it's not a deck file
    }

    private final ArrayList<String> outputMessages = new ArrayList<>();
    private int failed = 0;
    private int wrongAbilityStatsTotal = 0;
    private int wrongAbilityStatsGood = 0;
    private int wrongAbilityStatsBad = 0;

    private static Set<String> skipListGet(String listName) {
        return skipCheckLists.computeIfAbsent(listName, x -> new LinkedHashSet<>());
    }

    private static void skipListAddName(String listName, String set, String cardName) {
        skipListGet(listName).add(set + " - " + cardName);
    }

    private static void skipListAddName(String listName, String set) {
        skipListGet(listName).add(set);
    }

    private static boolean skipListHaveName(String listName, String set, String cardName) {
        return skipListGet(listName).contains(set + " - " + cardName)
                || skipListGet(listName).contains(set);
    }

    private static boolean skipListHaveName(String listName, String set) {
        return skipListGet(listName).contains(set);
    }

    /**
     * For splitting printed rules text with multiple keywords on one line
     */
    private static boolean evergreenCheck(String s) {
        return evergreenKeywords.contains(s) || s.startsWith("protection from") || s.startsWith("hexproof from")
                || s.startsWith("ward ") || s.startsWith("rampage ") || s.startsWith("annihilator")
                || s.matches("^firebending \\d");
    }

    private static <T> boolean eqSet(Collection<T> a, Collection<T> b) {
        if (a == null || a.isEmpty()) {
            return b == null || b.isEmpty();
        }
        return b != null && a.size() == b.size() && a.containsAll(b);
    }

    private void warn(Card card, String message) {
        outputMessages.add("Warning: " + message + " for " + card.getExpansionSetCode() + " - " + card.getName() + " - " + card.getCardNumber());
    }

    private void fail(Card card, String category, String message) {
        failed++;
        outputMessages.add("Error: (" + category + ") " + message + " for " + card.getExpansionSetCode() + " - " + card.getName() + " - " + card.getCardNumber());
    }

    @Test
    public void test_verifyCards() {
        checkWrongAbilitiesTextStart();

        int cardIndex = 0;
        List<Card> allCards = CardScanner.getAllCards(true, true, false);
        for (Card card : allCards) {
            cardIndex++;
            if (card instanceof CardWithHalves) {
                check(((CardWithHalves) card).getLeftHalfCard(), cardIndex);
                check(((CardWithHalves) card).getRightHalfCard(), cardIndex);
            } else if (card instanceof CardWithSpellOption) {
                check(card, cardIndex);
                check(((CardWithSpellOption) card).getSpellCard(), cardIndex);
            } else {
                check(card, cardIndex);
            }
        }

        checkWrongAbilitiesTextEnd();

        printMessages(outputMessages);
        if (failed > 0) {
            Assert.fail(String.format("found %d errors in %d cards verify (see errors list above)", failed, allCards.size()));
        }
    }

    @Test
    public void test_checkDuplicateCardNumbersInDB() {
        Collection<String> doubleErrors = new ArrayList<>();

        Collection<ExpansionSet> sets = Sets.getInstance().values();
        for (ExpansionSet set : sets) {
            Map<String, ExpansionSet.SetCardInfo> cardsList = new HashMap<>();
            for (ExpansionSet.SetCardInfo checkCard : set.getSetCardInfo()) {
                String cardNumber = checkCard.getCardNumber();

                // ignore double faced
                Card realCard = CardImpl.createCard(checkCard.getCardClass(), new CardSetInfo(checkCard.getName(), set.getCode(),
                        checkCard.getCardNumber(), checkCard.getRarity(), checkCard.getGraphicInfo()));
                if (realCard.isNightCard()) {
                    continue;
                }

                if (cardsList.containsKey(cardNumber)) {
                    ExpansionSet.SetCardInfo prevCard = cardsList.get(cardNumber);

                    String errorType;
                    if (checkCard.getName().equals(prevCard.getName())) {
                        errorType = " found DUPLICATED cards"
                                + " set (" + set.getCode() + " - " + set.getName() + ")"
                                + " (" + checkCard.getCardNumber() + " - " + checkCard.getName() + ")";
                    } else {
                        errorType = " found TYPOS in card numbers"
                                + " set (" + set.getCode() + " - " + set.getName() + ")"
                                + " (" + prevCard.getCardNumber() + " - " + prevCard.getName() + ")"
                                + " and"
                                + " (" + checkCard.getCardNumber() + " - " + checkCard.getName() + ")";
                    }

                    String error = "Error: " + errorType;

                    doubleErrors.add(error);
                } else {
                    cardsList.put(cardNumber, checkCard);
                }
            }
        }

        for (String error : doubleErrors) {
            System.out.println(error);
        }

        if (doubleErrors.size() > 0) {
            Assert.fail("DB has duplicated card numbers, found errors: " + doubleErrors.size());
        }
    }

    @Test
    @Ignore // TODO: enable it after THB set will be completed
    public void test_checkDoubleRareCardsInSets() {
        // all basic sets after THB must have double rare cards (one normal, one bonus)
        // ELD can have same rules, but xmage stores it as different sets (ELD and CELD)
        Date startCheck = TherosBeyondDeath.getInstance().getReleaseDate();
        Calendar cal = Calendar.getInstance();
        cal.set(2050, Calendar.JANUARY, 1); // optimistic
        Date endCheck = cal.getTime();

        Collection<String> doubleErrors = new ArrayList<>();

        Collection<ExpansionSet> sets = Sets.getInstance().values();
        for (ExpansionSet set : sets) {
            // only post THB sets must have double versions
            if (set.getReleaseDate().before(startCheck)
                    || set.getReleaseDate().after(endCheck)
                    || !set.getSetType().isStandardLegal()) {
                continue;
            }

            if (skipListHaveName(SKIP_LIST_DOUBLE_RARE, set.getCode())) {
                continue;
            }

            Map<String, Integer> cardsList = new HashMap<>();
            for (ExpansionSet.SetCardInfo checkCard : set.getSetCardInfo()) {
                // only rare cards must have double versions
                if (!Objects.equals(checkCard.getRarity(), Rarity.RARE) && !Objects.equals(checkCard.getRarity(), Rarity.MYTHIC)) {
                    continue;
                }

                if (skipListHaveName(SKIP_LIST_DOUBLE_RARE, set.getCode(), checkCard.getName())) {
                    continue;
                }

                String cardName = checkCard.getName();
                cardsList.putIfAbsent(cardName, 0);
                cardsList.compute(cardName, (k, v) -> v + 1);
            }

            cardsList.forEach((cardName, amount) -> {
                if (amount != 2) {
                    String error = "Error: non duplicated rare card -"
                            + " set (" + set.getCode() + " - " + set.getName() + ")"
                            + " card (" + cardName + ")";
                    doubleErrors.add(error);
                }
            });
        }

        for (String error : doubleErrors) {
            System.out.println(error);
        }

        if (doubleErrors.size() > 0) {
            Assert.fail("DB has non duplicated rare cards, found errors: " + doubleErrors.size());
        }
    }

    @Test
    public void test_checkWrongCardClasses() {
        Collection<String> errorsList = new ArrayList<>();
        Map<String, String> classesIndex = new HashMap<>();
        int totalCards = 0;

        Collection<ExpansionSet> sets = Sets.getInstance().values();
        for (ExpansionSet set : sets) {
            for (ExpansionSet.SetCardInfo checkCard : set.getSetCardInfo()) {
                totalCards = totalCards + 1;

                String currentClass = checkCard.getCardClass().toString();
                if (classesIndex.containsKey(checkCard.getName())) {
                    String needClass = classesIndex.get(checkCard.getName());
                    if (!needClass.equals(currentClass)) {
                        // workaround to star wars and unstable set with same card names
                        if (!checkCard.getName().equals("Syndicate Enforcer")
                                && !checkCard.getName().equals("Everythingamajig")
                                && !checkCard.getName().equals("Garbage Elemental")
                                && !checkCard.getName().equals("Very Cryptic Command")) {
                            errorsList.add("Error: wrong class in set " + set.getCode() + " - " + checkCard.getName() + " (" + currentClass + " <> " + needClass + ")");
                        }
                    }
                } else {
                    classesIndex.put(checkCard.getName(), currentClass);
                }
            }
        }

        printMessages(errorsList);

        // unique cards stats
        System.out.println("Total unique cards: " + classesIndex.size() + ", total non unique cards (reprints): " + totalCards);

        if (errorsList.size() > 0) {
            Assert.fail("DB has wrong card classes, found errors: " + errorsList.size());
        }
    }

    @Test
    public void test_checkMissingSets() {
        // generate unimplemented sets list
        Collection<String> info = new ArrayList<>();

        int missingSets = 0;
        int missingCards = 0;
        int unsupportedSets = 0;
        int unsupportedCards = 0;
        int mtgCards = 0;
        int mtgSets = 0;
        int xmageCards = 0;
        int xmageUnofficialSets = 0;
        int xmageUnofficialCards = 0;
        Collection<ExpansionSet> sets = Sets.getInstance().values();

        Assert.assertFalse("XMage data must contains sets list", sets.isEmpty());
        Assert.assertFalse("MtgJson data must contains sets list", MtgJsonService.sets().isEmpty());

        // official sets
        for (Map.Entry<String, MtgJsonSet> refEntry : MtgJsonService.sets().entrySet()) {
            MtgJsonSet refSet = refEntry.getValue();
            mtgCards += refSet.totalSetSize;

            // replace codes for aliases
            String searchSet = MtgJsonService.mtgJsonToXMageCodes.getOrDefault(refSet.code, refSet.code);
            if (skipListHaveName(SKIP_LIST_UNSUPPORTED_SETS, searchSet)) {
                unsupportedSets++;
                unsupportedCards += refSet.totalSetSize;
                continue;
            }

            ExpansionSet mageSet = Sets.findSet(searchSet.toUpperCase(Locale.ENGLISH));
            if (mageSet == null) {
                if (refSet.cards.isEmpty() || refSet.name.contains("Oversized")) {
                    unsupportedSets++;
                    unsupportedCards += refSet.totalSetSize;
                } else {
                    missingSets++;
                    missingCards = missingCards + refSet.cards.size();
                    if (!CHECK_ONLY_ABILITIES_TEXT) {
                        info.add("Warning: missing set " + refSet.code + " - " + refSet.name + " (cards: " + refSet.cards.size() + ", date: " + refSet.releaseDate + ")");
                    }
                }
                continue;
            }

            mtgSets++;
            xmageCards += mageSet.getSetCardInfo().size();
        }
        if (info.size() > 0) {
            info.add("Warning: total missing sets: " + missingSets + ", with missing cards: " + missingCards);
        }

        // unofficial sets info
        for (ExpansionSet set : sets) {
            if (MtgJsonService.sets().containsKey(set.getCode())) {
                continue;
            }

            xmageUnofficialSets++;
            xmageUnofficialCards += set.getSetCardInfo().size();
            info.add("Unofficial set: " + set.getCode() + " - " + set.getName() + ", cards: " + set.getSetCardInfo().size() + ", year: " + set.getReleaseYear());
        }

        printMessages(info);
        System.out.println();
        System.out.println("Official sets implementation stats:");
        System.out.println("* MTG sets: " + MtgJsonService.sets().size() + ", cards: " + mtgCards);
        System.out.println("* Implemented sets: " + mtgSets + ", cards: " + xmageCards);
        System.out.println("* Unsupported sets: " + unsupportedSets + ", cards: " + unsupportedCards);
        System.out.println("* TODO sets: " + (MtgJsonService.sets().size() - mtgSets - unsupportedSets) + ", cards: " + (mtgCards - xmageCards - unsupportedCards));
        System.out.println();
        System.out.println("Unofficial sets implementation stats:");
        System.out.println("* Implemented sets: " + xmageUnofficialSets + ", cards: " + xmageUnofficialCards);
        System.out.println();
    }

    @Test
    public void test_checkSampleDecks() {
        Collection<String> errorsList = new ArrayList<>();

        // workaround to run verify test from IDE or from maven's project root folder
        Path rootPath = Paths.get("Mage.Client", "release", "sample-decks");
        if (!Files.exists(rootPath)) {
            rootPath = Paths.get("..", "Mage.Client", "release", "sample-decks");
        }
        if (!Files.exists(rootPath)) {
            Assert.fail("Sample decks: unknown root folder " + rootPath.toAbsolutePath());
        }

        // collect all files in all root's folders
        Collection<Path> filesList = new ArrayList<>();
        try {
            Files.walkFileTree(rootPath, new SimpleFileVisitor<Path>() {
                @Override
                public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) throws IOException {
                    filesList.add(file);
                    return FileVisitResult.CONTINUE;
                }
            });
        } catch (IOException e) {
            e.printStackTrace();
            errorsList.add("Error: sample deck - can't get folder content - " + e.getMessage());
        }
        Assert.assertTrue("Sample decks: can't find any deck files in " + rootPath.toAbsolutePath(), filesList.size() > 0);

        // try to open deck files
        int totalErrorFiles = 0;
        for (Path deckFile : filesList) {
            String deckName = rootPath.relativize(deckFile).toString();
            if (!deckName.endsWith(".dck") || skipListHaveName(SKIP_LIST_SAMPLE_DECKS, deckName)) {
                continue;
            }

            StringBuilder deckErrors = new StringBuilder();
            DeckCardLists deckCards = DeckImporter.importDeckFromFile(deckFile.toString(), deckErrors, AUTO_FIX_SAMPLE_DECKS);

            if (!deckErrors.toString().isEmpty()) {
                errorsList.add("Error: sample deck contains errors " + deckName);
                System.out.println("Errors in sample deck " + deckName + ":\n" + deckErrors);
                totalErrorFiles++;
                continue;
            }

            if ((deckCards.getCards().size() + deckCards.getSideboard().size()) < 10) {
                // note: does not check whether cards are extra deck cards (contraptions/attractions);
                // may succeed for decks with such cards when it should fail
                errorsList.add("Error: sample deck contains too little cards (" + deckCards.getSideboard().size() + ") " + deckName);
                totalErrorFiles++;
                continue;
            }
        }

        printMessages(errorsList);
        if (errorsList.size() > 0) {
            Assert.fail("Found sample decks: " + filesList.size() + "; with errors: " + totalErrorFiles);
        }
    }

    @Test
    public void test_checkMissingSecondSideCardsInSets() {
        Collection<String> errorsList = new ArrayList<>();

        // CHECK: if card have second side (flip, transform) then it must have all sides in that set
        for (ExpansionSet set : Sets.getInstance().values()) {
            for (ExpansionSet.SetCardInfo info : set.getSetCardInfo()) {
                CardInfo cardInfo = CardRepository.instance.findCardsByClass(info.getCardClass().getCanonicalName()).stream().findFirst().orElse(null);
                Assert.assertNotNull(cardInfo);

                if (cardInfo.isDoubleFacedCard()) {
                    break;
                }
                Card card = cardInfo.createCard();
                Card secondCard = card.getSecondCardFace();
                if (secondCard != null) {
                    if (set.findCardInfoByClass(secondCard.getClass()).isEmpty()) {
                        errorsList.add("Error: missing second face card from set: " + set.getCode() + " - " + set.getName() + " - main: " + card.getName() + "; second: " + secondCard.getName());
                    }
                }
            }
        }

        printMessages(errorsList);
        if (errorsList.size() > 0) {
            Assert.fail("Found missing second side cards in sets, errors: " + errorsList.size());
        }
    }

    @Test
    @Ignore // TODO: enable after all missing cards and settings fixes
    public void test_checkWrongCardsDataInSets() {
        Collection<String> errorsList = new ArrayList<>();
        Collection<String> warningsList = new ArrayList<>();
        Collection<ExpansionSet> xmageSets = Sets.getInstance().values();
        Set<String> foundedJsonCards = new HashSet<>();

        // fast check instead card's db search (only main side card)
        Set<String> implementedIndex = new HashSet<>();
        CardRepository.instance.findCards(new CardCriteria()).forEach(card -> {
            implementedIndex.add(card.getName());
        });

        // CHECK: wrong card numbers
        for (ExpansionSet set : xmageSets) {
            if (skipListHaveName(SKIP_LIST_WRONG_CARD_NUMBERS, set.getCode())) {
                continue;
            }

            for (ExpansionSet.SetCardInfo card : set.getSetCardInfo()) {
                MtgJsonCard jsonCard = MtgJsonService.cardFromSet(set.getCode(), card.getName(), card.getCardNumber());
                if (jsonCard == null) {
                    // see convertMtgJsonToXmageCardNumber for card number convert notation
                    errorsList.add("Error: unknown mtgjson's card number or set, use standard number notations: "
                            + set.getCode() + " - " + set.getName() + " - " + card.getName() + " - " + card.getCardNumber());
                    continue;
                }

                // index for missing cards
//                String code = MtgJsonService.xMageToMtgJsonCodes.getOrDefault(set.getCode(), set.getCode()) + " - " + jsonCard.getNameAsFull() + " - " + jsonCard.number;
//                foundedJsonCards.add(code);
//
            }
        }

        // CHECK: missing cards from set
        for (MtgJsonSet jsonSet : MtgJsonService.sets().values()) {
            if (skipListHaveName(SKIP_LIST_UNSUPPORTED_SETS, jsonSet.code)
                    || skipListHaveName(SKIP_LIST_WRONG_CARD_NUMBERS, jsonSet.code)) {
                continue;
            }

            ExpansionSet xmageSet = Sets.findSet(jsonSet.code);
            if (xmageSet == null) {
                ExpansionSet sameSet = Sets.findSetByName(jsonSet.name);
                if (sameSet != null) {
                    warningsList.add("Warning: implemented set with different set code: "
                            + jsonSet.code + " - " + jsonSet.name + " - " + jsonSet.releaseDate
                            + " (xmage's set under code: " + sameSet.getCode() + ")"
                    );
                } else {
                    warningsList.add("Warning: un-implemented set from mtgjson: " + jsonSet.code + " - " + jsonSet.name + " - " + jsonSet.releaseDate);
                }
                continue;
            }

            for (MtgJsonCard jsonCard : jsonSet.cards) {
                String code = jsonSet.code + " - " + jsonCard.getNameAsFull() + " - " + jsonCard.number;
                if (!foundedJsonCards.contains(code)) {
                    if (!implementedIndex.contains(jsonCard.getNameAsFull())) {
                        warningsList.add("Warning: un-implemented card from mtgjson: " + jsonSet.code + " - " + jsonCard.getNameAsFull() + " - " + jsonCard.number);
                    } else {
                        errorsList.add("Error: missing card from xmage's set: " + jsonSet.code + " - " + jsonCard.getNameAsFull() + " - " + jsonCard.number);
                    }
                }
            }
        }

        printMessages(warningsList);
        printMessages(errorsList);
        if (errorsList.size() > 0) {
            Assert.fail("Found wrong cards data in sets, errors: " + errorsList.size());
        }
    }

    @Test
    @Ignore
    public void test_checkWrongFullArtAndRetro() {
        Collection<String> errorsList = new ArrayList<>();
        Collection<ExpansionSet> xmageSets = Sets.getInstance().values();

        // CHECK: wrong card numbers
        for (ExpansionSet set : xmageSets) {
            if (skipListHaveName(SKIP_LIST_WRONG_CARD_NUMBERS, set.getCode())) {
                continue;
            }

            for (ExpansionSet.SetCardInfo card : set.getSetCardInfo()) {
                MtgJsonCard jsonCard = MtgJsonService.cardFromSet(set.getCode(), card.getName(), card.getCardNumber());
                if (jsonCard == null) {
                    continue;
                }

                // CHECK: full art lands must use full art setting
                // CHECK: non-full art lands must not use full art setting
                // CHECK: if full art land is using full art setting, don't perform retro or poster tests
                boolean isLand = card.getRarity().equals(Rarity.LAND);
                if (isLand && jsonCard.isFullArt && !card.isFullArt()) {
                    errorsList.add("Error: card must use full art lands setting: "
                            + set.getCode() + " - " + set.getName() + " - " + card.getName() + " - " + card.getCardNumber());
                    continue;
                } else if (isLand && !jsonCard.isFullArt && card.isFullArt()) {
                    errorsList.add("Error: card must NOT use full art lands setting: "
                            + set.getCode() + " - " + set.getName() + " - " + card.getName() + " - " + card.getCardNumber());
                    continue;
                } else if (isLand && jsonCard.isFullArt && card.isFullArt()) {
                    // Land full art is correct, skip other tests
                    continue;
                }

                // CHECK: poster promoType and/or textless must use full art setting
                if (((jsonCard.promoTypes != null && jsonCard.promoTypes.contains("poster")) || jsonCard.isTextless) && !card.isFullArt()) {
                    errorsList.add("Error: card must use full art setting: "
                            + set.getCode() + " - " + set.getName() + " - " + card.getName() + " - " + card.getCardNumber());
                }

                // CHECK: must use retro frame setting
                if ((jsonCard.frameVersion.equals("1993") || jsonCard.frameVersion.equals("1997")) && !card.isRetroFrame()) {
                    errorsList.add("Error: card must use retro art setting: "
                            + set.getCode() + " - " + set.getName() + " - " + card.getName() + " - " + card.getCardNumber());
                }

                // CHECK: must not use retro frame setting
                if ((!(jsonCard.frameVersion.equals("1993") || jsonCard.frameVersion.equals("1997"))) && card.isRetroFrame()) {
                    errorsList.add("Error: card must NOT use retro art setting: "
                            + set.getCode() + " - " + set.getName() + " - " + card.getName() + " - " + card.getCardNumber());
                }
            }
        }

        printMessages(errorsList);
        if (errorsList.size() > 0) {
            Assert.fail("Found wrong cards data in sets, errors: " + errorsList.size());
        }
    }

    @Test
    @Ignore // TODO: enable after all missing cards and settings fixes
    public void test_checkMissingScryfallSettingsAndCardNumbers() {
        Collection<String> errorsList = new ArrayList<>();

        Collection<ExpansionSet> xmageSets = Sets.getInstance().values();
        Set<String> scryfallSets = ScryfallImageSupportCards.getSupportedSets();

        // CHECK: missing sets in supported list
        for (ExpansionSet set : xmageSets) {
            if (skipListHaveName(SKIP_LIST_SCRYFALL_DOWNLOAD_SETS, set.getCode())) {
                continue;
            }

            if (!scryfallSets.contains(set.getCode())) {
                errorsList.add("Error: scryfall download missing setting: " + set.getCode() + " - " + set.getName());
            }
        }

        // CHECK: unknown sets in supported list
        for (String scryfallCode : scryfallSets) {
            if (xmageSets.stream().noneMatch(e -> e.getCode().equals(scryfallCode))) {
                errorsList.add("Error: scryfall download unknown setting: " + scryfallCode);
            }
        }

        // card numbers
        // all cards with non-ascii numbers must be downloaded by direct links (api)
        Set<String> foundedDirectDownloadKeys = new HashSet<>();
        for (ExpansionSet set : xmageSets) {
            if (skipListHaveName(SKIP_LIST_SCRYFALL_DOWNLOAD_SETS, set.getCode())
                    || skipListHaveName(SKIP_LIST_WRONG_CARD_NUMBERS, set.getCode())) {
                continue;
            }

            for (ExpansionSet.SetCardInfo card : set.getSetCardInfo()) {
                if (skipListHaveName(SKIP_LIST_WRONG_CARD_NUMBERS, set.getCode(), card.getName())) {
                    continue;
                }

                MtgJsonCard jsonCard = MtgJsonService.cardFromSet(set.getCode(), card.getName(), card.getCardNumber());
                if (jsonCard == null) {
                    // see convertMtgJsonToXmageCardNumber for card number convert notation
                    if (!skipListHaveName(SKIP_LIST_WRONG_CARD_NUMBERS, set.getCode(), card.getName())) {
                        errorsList.add("Error: scryfall download can't find card from mtgjson " + set.getCode() + " - " + set.getName() + " - " + card.getName() + " - " + card.getCardNumber());
                    }
                    continue;
                }

                // CHECK: non-ascii numbers and direct download list
                if (!CharMatcher.ascii().matchesAllOf(jsonCard.number)) {
                    // non-ascii numbers
                    // xmage card numbers can't have non-ascii numbers (it checked by test_checkMissingCardData)
                    String key = ScryfallImageSupportCards.findDirectDownloadKey(set.getCode(), card.getName(), card.getCardNumber());
                    if (key != null) {
                        foundedDirectDownloadKeys.add(key);
                    } else {
                        // how-to fix: add miss images links in ScryfallImageSupportCards->directDownloadLinks
                        errorsList.add("Error: scryfall download can't find non-ascii card link in direct download list " + set.getCode() + " - " + set.getName() + " - " + card.getName() + " - " + jsonCard.number);
                    }
                }

                // CHECK: reversible_card must be in direct download list (xmage must have 2 cards with diff image face)
                if (jsonCard.layout.equals("reversible_card")) {
                    String key = ScryfallImageSupportCards.findDirectDownloadKey(set.getCode(), card.getName(), card.getCardNumber());
                    if (key != null) {
                        foundedDirectDownloadKeys.add(key);
                    } else {
                        errorsList.add("Error: scryfall download can't find face image of reversible_card in direct download list " + set.getCode() + " - " + set.getName() + " - " + card.getName() + " - " + jsonCard.number);
                    }
                }
            }
        }

        // CHECK: unknown direct download links
        // TODO: add same for tokens
        for (Map.Entry<String, String> direct : ScryfallImageSupportCards.getDirectDownloadLinks().entrySet()) {
            // skip custom sets
            String setCode = ScryfallImageSupportCards.extractSetCodeFromDirectKey(direct.getKey());
            String cardName = ScryfallImageSupportCards.extractCardNameFromDirectKey(direct.getKey());
            if (skipListHaveName(SKIP_LIST_SCRYFALL_DOWNLOAD_SETS, setCode)
                    || skipListHaveName(SKIP_LIST_WRONG_CARD_NUMBERS, setCode)) {
                continue;
            }

            // skip non-implemented cards list
            if (CardRepository.instance.findCard(cardName) == null) {
                continue;
            }

            if (!foundedDirectDownloadKeys.contains(direct.getKey())) {
                errorsList.add("Error: scryfall download found unknown direct download link " + direct.getKey() + " - " + direct.getValue());
            }
        }

        printMessages(errorsList);
        if (errorsList.size() > 0) {
            Assert.fail("Found scryfall download errors: " + errorsList.size());
        }
    }

    private Object createNewObject(Class<?> clazz) {
        try {
            Constructor<?> cons = clazz.getConstructor();
            return cons.newInstance();
        } catch (InvocationTargetException ex) {
            Throwable e = ex.getTargetException();
            e.printStackTrace();
            return null;
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

    private void printMessages(Collection<String> list, boolean sorted) {

        ArrayList<String> sortedList = new ArrayList<>(list);
        if (sorted) {
            sortedList.sort(new Comparator<String>() {
                @Override
                public int compare(String o1, String o2) {
                    // show errors in the end of the list (after warnings, near the final assert fail)
                    boolean e1 = o1.toLowerCase(Locale.ENGLISH).startsWith("error");
                    boolean e2 = o2.toLowerCase(Locale.ENGLISH).startsWith("error");
                    if (e1 != e2) {
                        return Boolean.compare(e1, e2);
                    } else {
                        return o1.compareTo(o2);
                    }
                }
            });
        }

        for (String mes : sortedList) {
            System.out.println(mes);
        }
    }

    private void printMessages(Collection<String> list) {
        printMessages(list, true);
    }

    private String extractShortClass(Class<? extends Object> tokenClass) {
        String origin = tokenClass.getName();
        if (origin.contains("$")) {
            // inner classes, example: mage.cards.f.FigureOfDestiny$FigureOfDestinyToken3
            return origin.replaceAll(".+\\$(.+)", "$1");
        } else {
            // public classes, example: mage.game.permanent.token.FigureOfDestinyToken
            return origin.replaceAll(".+\\.(.+)", "$1");
        }
    }

    private static final Set<String> ignoreBoosterSets = new HashSet<>();

    static {
        // jumpstart, TODO: implement from JumpstartPoolGenerator, see #13264
        ignoreBoosterSets.add("Jumpstart");
        ignoreBoosterSets.add("Jumpstart 2022");
        ignoreBoosterSets.add("Foundations Jumpstart");
        ignoreBoosterSets.add("Ravnica: Clue Edition");
        ignoreBoosterSets.add("Avatar: The Last Airbender Eternal");
        // joke or un-sets, low implemented cards
        ignoreBoosterSets.add("Unglued");
        ignoreBoosterSets.add("Unhinged");
        ignoreBoosterSets.add("Unstable");
        ignoreBoosterSets.add("Unfinity");
        // other
        ignoreBoosterSets.add("Secret Lair Drop"); // cards shop
        ignoreBoosterSets.add("Zendikar Rising Expeditions"); // box toppers
        ignoreBoosterSets.add("March of the Machine: The Aftermath"); // epilogue boosters aren't for draft
    }

    @Test
    public void test_checkMissingSetData() {
        Collection<String> errorsList = new ArrayList<>();
        Collection<String> warningsList = new ArrayList<>();

        Collection<ExpansionSet> sets = Sets.getInstance().values();

        // CHECK: wrong set class names
        for (ExpansionSet set : sets) {
            String className = extractShortClass(set.getClass());
            String needClassName = Arrays.stream(
                    set.getName()
                            .replaceAll("&", "And")
                            .replaceAll("^(\\d+)", "The$1") // replace starting "2007 xxx" by "The2007"
                            .replace("-", " ")
                            .replaceAll("[.+-/:\"']", "")
                            .split(" ")
            ).map(CardUtil::getTextWithFirstCharUpperCase).reduce("", String::concat);

            if (!className.equals(needClassName)) {
                // if set name start with a numbers then add "The" at the start
                errorsList.add("Error: set's class name must be equal to set name: "
                        + className + " from " + set.getClass().getName() + ", caption: " + set.getName() + ", need name: " + needClassName);
            }
        }

        // CHECK: wrong basic lands settings (it's for lands search, not booster construct)
        for (ExpansionSet set : sets) {
            boolean needLand = set.hasBasicLands();
            boolean foundLand = false;
            Map<String, Integer> foundLandsList = new HashMap<>();
            for (ExpansionSet.SetCardInfo card : set.getSetCardInfo()) {
                if (isBasicLandName(card.getName())) {
                    foundLand = true;
                    int count = foundLandsList.getOrDefault(card.getName(), 0);
                    foundLandsList.put(card.getName(), count + 1);
                }
            }

            String landNames = foundLandsList.entrySet().stream()
                    .map(p -> (p.getKey() + " - " + p.getValue().toString()))
                    .sorted().collect(Collectors.joining(", "));

            if (needLand && !foundLand) {
                errorsList.add("Error: set with wrong hasBasicLands - it's true, but haven't land cards: " + set.getCode() + " in " + set.getClass().getName());
            }

            if (!needLand && foundLand) {
                errorsList.add("Error: set with wrong hasBasicLands - it's false, but have land cards: " + set.getCode() + " in " + set.getClass().getName() + ", lands: " + landNames);
            }

            // TODO: add test to check num cards (hasBasicLands and numLand > 0)
        }

        // CHECK: wrong snow land info - set needs to have exclusively snow basics to qualify
        for (ExpansionSet set : sets) {
            boolean needSnow = CardRepository.haveSnowLands(set.getCode());
            boolean haveSnow = false;
            boolean haveNonSnow = false;
            for (ExpansionSet.SetCardInfo card : set.getSetCardInfo()) {
                if (card.getName().startsWith("Snow-Covered ")) {
                    haveSnow = true;
                }
                if (isNonSnowBasicLandName(card.getName())) {
                    haveNonSnow = true;
                    break;
                }
            }
            if (needSnow != (haveSnow && !haveNonSnow)) {
                errorsList.add("Error: incorrect snow land info in set " + set.getCode() + ": "
                        + ((haveSnow && !haveNonSnow) ? "set has exclusively snow basics" : "set doesn't have exclusively snow basics")
                        + ", but xmage thinks that it " + (needSnow ? "does" : "doesn't"));
            }
        }

        // CHECK: unknown set or wrong name
        for (ExpansionSet set : sets) {
            if (set.getSetType().equals(SetType.CUSTOM_SET)) {
                // skip unofficial sets like Star Wars
                continue;
            }

            MtgJsonSet jsonSet = MtgJsonService.sets().getOrDefault(set.getCode().toUpperCase(Locale.ENGLISH), null);
            if (jsonSet == null) {
                errorsList.add(String.format("Error: unknown official set: %s - %s (make sure it use correct set code or mark it as SetType.CUSTOM_SET)",
                        set.getCode(),
                        set.getName()
                ));
            } else {
                if (!Objects.equals(set.getName(), jsonSet.name)) {
                    // how-to fix: rename xmage set to the json version or fix a set's code
                    // also don't forget to change names in mtg-cards-data.txt
                    errorsList.add(String.format("Error: wrong set name or set code: %s (mtgjson set for same code: %s)",
                            set.getCode() + " - " + set.getName(),
                            jsonSet.name
                    ));
                }
            }
        }

        // CHECK: parent and block info
        // TODO: it's UX problem, see https://github.com/magefree/mage/issues/10184
        for (ExpansionSet set : sets) {
            if (true) {
                continue; // TODO: comments it and run to find a problems
            }
            MtgJsonSet jsonSet = MtgJsonService.sets().getOrDefault(set.getCode().toUpperCase(Locale.ENGLISH), null);
            if (jsonSet == null) {
                continue;
            }

            // parent set
            MtgJsonSet jsonParentSet = jsonSet.parentCode == null ? null : MtgJsonService.sets().getOrDefault(jsonSet.parentCode, null);
            ExpansionSet mageParentSet = set.getParentSet();
            String jsonParentCode = jsonParentSet == null ? "null" : jsonParentSet.code;
            String mageParentCode = mageParentSet == null ? "null" : mageParentSet.getCode();

            String needMageClass = "";
            if (!jsonParentCode.equals("null")) {
                needMageClass = sets
                        .stream()
                        .filter(exp -> exp.getCode().equals(jsonParentCode))
                        .map(exp -> " - " + exp.getClass().getSimpleName() + ".getInstance()")
                        .findFirst()
                        .orElse("- error, can't find class");
            }

            if (!Objects.equals(jsonParentCode, mageParentCode)) {
                errorsList.add(String.format("Error: set with wrong parentSet settings: %s (parentSet = %s, but must be %s%s)",
                        set.getCode() + " - " + set.getName(),
                        mageParentCode,
                        jsonParentCode,
                        needMageClass
                ));
            }

            // block info
            if (!Objects.equals(set.getBlockName(), jsonSet.block)) {
                if (true) {
                    continue; // TODO: comments it and run to find a problems
                }
                errorsList.add(String.format("Error: set with wrong blockName settings: %s (blockName = %s, but must be %s)",
                        set.getCode() + " - " + set.getName(),
                        set.getBlockName(),
                        jsonSet.block
                ));
            }
        }

        // CHECK: miss booster settings
        // make sure mtgjson has booster data
        boolean hasBoostersInfo = MtgJsonService.sets().values().stream().anyMatch(s -> s.booster != null && !s.booster.isEmpty());
        for (ExpansionSet set : sets) {
            if (!hasBoostersInfo) {
                System.out.println("Warning, mtgjson data lost boosters info");
                break;
            }
            MtgJsonSet jsonSet = MtgJsonService.sets().getOrDefault(set.getCode().toUpperCase(Locale.ENGLISH), null);
            if (jsonSet == null) {
                continue;
            }
            boolean needBooster = jsonSet.booster != null && !jsonSet.booster.isEmpty();
            if (set.hasBoosters() != needBooster) {
                if (ignoreBoosterSets.contains(set.getName())) {
                    continue;
                }
                // error example: wrong booster settings (set MUST HAVE booster, but haven't) - 2020 - J22 - Jumpstart 2022 - boosters: [jumpstart]
                errorsList.add(String.format("Error: wrong booster settings (set %s booster, but %s) - %s%s",
                        (needBooster ? "MUST HAVE" : "MUST HAVEN'T"),
                        (set.hasBoosters() ? "have" : "haven't"),
                        set.getReleaseYear() + " - " + set.getCode() + " - " + set.getName(),
                        (jsonSet.booster == null ? "" : " - boosters: " + jsonSet.booster.keySet())
                ));
            }
        }

        // CHECK: missing important sets for draft format
        Set<String> implementedSets = sets.stream().map(ExpansionSet::getCode).collect(Collectors.toSet());
        MtgJsonService.sets().values().forEach(jsonSet -> {
            if (jsonSet.booster != null && !jsonSet.booster.isEmpty() && !implementedSets.contains(jsonSet.code)) {
                // how-to fix: it's miss promo sets with boosters, so just add/generate it in most use cases
                errorsList.add(String.format("Error: missing set implementation (important for draft format) - %s - %s - boosters: %s",
                        jsonSet.code,
                        jsonSet.name,
                        jsonSet.booster.keySet()
                ));
            }
        });

        // TODO: add test to check num cards for rarity (rarityStats > 0 and numRarity > 0)
        printMessages(warningsList);
        printMessages(errorsList);
        if (errorsList.size() > 0) {
            Assert.fail("Found set errors: " + errorsList.size());
        }
    }

    @Test
    public void test_checkMissingCardData() {
        Collection<String> errorsList = new ArrayList<>();
        Collection<String> warningsList = new ArrayList<>();

        Collection<ExpansionSet> sets = Sets.getInstance().values();

        // CHECK: wrong UsesVariousArt settings (set have duplicated card name without that setting -- e.g. cards will have same image)
        for (ExpansionSet set : sets) {

            Map<String, Integer> doubleNames = new HashMap<>();
            for (ExpansionSet.SetCardInfo card : set.getSetCardInfo()) {
                int count = doubleNames.getOrDefault(card.getName(), 0);
                doubleNames.put(card.getName(), count + 1);
            }

            for (ExpansionSet.SetCardInfo card : set.getSetCardInfo()) {
                boolean cardHaveDoubleName = (doubleNames.getOrDefault(card.getName(), 0) > 1);
                boolean cardHaveVariousSetting = card.getGraphicInfo() != null && card.getGraphicInfo().getUsesVariousArt();

                if (cardHaveDoubleName && !cardHaveVariousSetting) {
                    errorsList.add("Error: double faced card, but UsesVariousArt = false (missing NON_FULL_USE_VARIOUS, etc): "
                            + set.getCode() + " - " + set.getName() + " - " + card.getName() + " - " + card.getCardNumber());
                }
            }
        }

        for (ExpansionSet set : sets) {
            // additional info
            Set<String> cardNames = new HashSet<>();
            for (ExpansionSet.SetCardInfo cardInfo : set.getSetCardInfo()) {
                cardNames.add(cardInfo.getName());
            }

            // CHECK: set code must be compatible with tests commands format like "SET-card"
            // how-to fix: change min/max lookup length
            if (set.getCode().length() < CardUtil.TESTS_SET_CODE_MIN_LOOKUP_LENGTH
                    || set.getCode().length() > CardUtil.TESTS_SET_CODE_MAX_LOOKUP_LENGTH) {
                errorsList.add("Error: set code un-supported by test commands lookup: " + set.getCode()
                        + ", min length: " + CardUtil.TESTS_SET_CODE_MIN_LOOKUP_LENGTH
                        + ", max length: " + CardUtil.TESTS_SET_CODE_MAX_LOOKUP_LENGTH);
            }

            boolean containsDoubleSideCards = false;
            Map<String, String> cardNumbers = new HashMap<>();
            for (ExpansionSet.SetCardInfo cardInfo : set.getSetCardInfo()) {
                Card card = CardImpl.createCard(cardInfo.getCardClass(), new CardSetInfo(cardInfo.getName(), set.getCode(),
                        cardInfo.getCardNumber(), cardInfo.getRarity(), cardInfo.getGraphicInfo()));
                Assert.assertNotNull(card);

                //TODO: do we need this check after tdfc rework?
                if (card.getSecondCardFace() != null && !(card instanceof DoubleFacedCard)) {
                    containsDoubleSideCards = true;
                }

                // CHECK: all planeswalkers must be legendary
                if (card.isPlaneswalker() && !card.isLegendary()) {
                    errorsList.add("Error: planeswalker must have legendary type: " + set.getCode() + " - " + set.getName() + " - " + card.getName() + " - " + card.getCardNumber());
                }

                // CHECK: getMana must works without NPE errors (it uses getNetMana with empty game param for AI score calcs)
                // https://github.com/magefree/mage/issues/6300
                card.getMana();

                // CHECK: non ascii symbols in card name and number
                if (!CharMatcher.ascii().matchesAllOf(card.getName()) || !CharMatcher.ascii().matchesAllOf(card.getCardNumber())) {
                    errorsList.add("Error: card name or number contains non-ascii symbols: " + set.getCode() + " - " + set.getName() + " - " + card.getName() + " - " + card.getCardNumber());
                }

                // CHECK: set code and card name must be parseable for test and cheat commands XLN-Mountain
                List<String> cardCommand = SystemUtil.parseSetAndCardNameCommand(set.getCode() + CardUtil.TESTS_SET_CODE_DELIMETER + card.getName());
                if (!Objects.equals(set.getCode(), cardCommand.get(0))
                        || !Objects.equals(card.getName(), cardCommand.get(1))) {
                    // if you catch it then parser logic must be changed to support problem set-card combination
                    errorsList.add("Error: card name can't be used in tests and cheats with set code: " + set.getCode() + " - " + set.getName() + " - " + card.getName() + " - " + card.getCardNumber());
                }

                // CHECK: card number must start with 09-aZ symbols (wrong symbol example: *123)
                // if you found card with number like *123 then report it to scryfall to fix to 123*
                if (!Character.isLetterOrDigit(card.getCardNumber().charAt(0))) {
                    errorsList.add("Error: card number must start with digit: " + set.getCode() + " - " + set.getName() + " - " + card.getName() + " - " + card.getCardNumber());
                }

                // CHECK: second side cards in one set
                // https://github.com/magefree/mage/issues/8081
                /*
                if (card.getSecondCardFace() != null && cardNames.contains(card.getSecondCardFace().getName())) {
                    errorsList.add("Error: set contains second side cards: " + set.getCode() + " - " + set.getName()
                            + " - " + card.getName() + " - " + card.getCardNumber()
                            + " - " + card.getSecondCardFace().getName() + " - " + card.getSecondCardFace().getCardNumber());
                }
                //*/

                // CHECK: set contains both card sides
                // related to second side cards usage
                /*
                String existedCardName = cardNumbers.getOrDefault(card.getCardNumber(), null);
                if (existedCardName != null && !existedCardName.equals(card.getName())) {
                    String info = card.isNightCard() ? existedCardName + " -> " + card.getName() : card.getName() + " -> " + existedCardName;
                    errorsList.add("Error: set contains both card sides instead main only: "
                            + set.getCode() + " - " + set.getName() + " - " + info + " - " + card.getCardNumber());
                } else {
                    cardNumbers.put(card.getCardNumber(), card.getName());
                }
                //*/
            }

            // CHECK: double side cards must be in boosters
            boolean hasBoosterSettings = (set.getNumBoosterDoubleFaced() > 0);
            if (set.hasBoosters()
                    && (set.getNumBoosterDoubleFaced() != -1) // -1 must ignore double cards in booster
                    && containsDoubleSideCards
                    && !hasBoosterSettings) {
                errorsList.add("Error: set with boosters contains second side cards, but numBoosterDoubleFaced is not set - "
                        + set.getCode() + " - " + set.getName());
            }
        }

        printMessages(warningsList);
        printMessages(errorsList);
        if (errorsList.size() > 0) {
            Assert.fail("Found card errors: " + errorsList.size());
        }
    }

    @Test
    public void test_checkWatcherCopyMethods() {

        Collection<String> errorsList = new ArrayList<>();
        Collection<String> warningsList = new ArrayList<>();

        Reflections reflections = new Reflections("mage.");
        Set<Class<? extends Watcher>> watcherClassesList = reflections.getSubTypesOf(Watcher.class);

        for (Class<? extends Watcher> watcherClass : watcherClassesList) {

            // only watcher class can be extended (e.g. final)
            if (!watcherClass.getSuperclass().equals(Watcher.class)) {
                errorsList.add("Error: only Watcher class can be extended: " + watcherClass.getName());
            }

            // no copy methods
            try {
                Method m = watcherClass.getMethod("copy");
                if (!m.getGenericReturnType().getTypeName().equals("T")) {
                    errorsList.add("Error: copy() method must be deleted from watcher class: " + watcherClass.getName());
                }
            } catch (NoSuchMethodException e) {
                errorsList.add("Error: can't find copy() method in watcher class: " + watcherClass.getName());
            }

            // no constructor for copy
            try {
                Constructor<? extends Watcher> constructor = watcherClass.getDeclaredConstructor(watcherClass);
                errorsList.add("Error: copy constructor is not allowed in watcher class: " + watcherClass.getName());
            } catch (NoSuchMethodException e) {
                // all fine, no needs in copy constructors
            }

            // errors on create
            try {
                List<?> constructors = Arrays.asList(watcherClass.getDeclaredConstructors());

                Constructor<? extends Watcher> constructor = (Constructor<? extends Watcher>) constructors.get(0);

                Object[] args = new Object[constructor.getParameterCount()];
                for (int index = 0; index < constructor.getParameterTypes().length; index++) {
                    Class<?> parameterType = constructor.getParameterTypes()[index];
                    if (parameterType.getSimpleName().equalsIgnoreCase("boolean")) {
                        args[index] = false;
                    } else {
                        args[index] = null;
                    }

                }

                constructor.setAccessible(true);
                Watcher w1 = constructor.newInstance(args);

                // errors on copy
                try {
                    Watcher w2 = w1.copy();
                    if (w2 == null) {
                        errorsList.add("Error: can't copy watcher with unknown error, look at error logs above: " + watcherClass.getName());
                    }
                } catch (Exception e) {
                    errorsList.add("Error: can't copy watcher: " + watcherClass.getName() + " (" + e.getMessage() + ")");
                }
            } catch (Exception e) {
                errorsList.add("Error: can't create watcher: " + watcherClass.getName() + " (" + e.getMessage() + ")");
            }

        }

        printMessages(warningsList);
        printMessages(errorsList);
        if (errorsList.size() > 0) {
            Assert.fail("Found watcher errors: " + errorsList.size());
        }
    }

    @Test
    @Ignore  // TODO: enable test after massive token fixes
    public void test_checkMissingTokenData() {

        Collection<String> errorsList = new ArrayList<>();
        Collection<String> warningsList = new ArrayList<>();

        // all tokens must be stores in tokens-database.txt (if not then viewer and image downloader are missing token images)
        // https://github.com/ronmamo/reflections
        Reflections reflections = new Reflections("mage.");
        Set<Class<? extends TokenImpl>> tokenClassesList = reflections.getSubTypesOf(TokenImpl.class);

        // xmage tokens
        Set<Class<? extends TokenImpl>> privateTokens = new HashSet<>();
        Set<Class<? extends TokenImpl>> publicTokens = new HashSet<>();
        for (Class<? extends TokenImpl> tokenClass : tokenClassesList) {
            if (Modifier.isPublic(tokenClass.getModifiers())) {
                publicTokens.add(tokenClass);
            } else {
                privateTokens.add(tokenClass);
            }
        }
        // xmage sets
        Set<String> allSetCodes = Sets.getInstance().values().stream().map(ExpansionSet::getCode).collect(Collectors.toSet());
        allSetCodes.add(TokenRepository.XMAGE_TOKENS_SET_CODE); // reminder tokens


        // tok file's data
        List<TokenInfo> tokFileTokens = TokenRepository.instance.getAll();
        LinkedHashMap<String, String> tokDataClassesIndex = new LinkedHashMap<>();
        LinkedHashMap<String, String> tokDataNamesIndex = new LinkedHashMap<>();
        LinkedHashMap<String, List<TokenInfo>> tokDataTokensBySetIndex = new LinkedHashMap<>();
        for (TokenInfo tokData : tokFileTokens) {

            String searchName;
            String setsList;

            // by set
            List<TokenInfo> tokensInSet = tokDataTokensBySetIndex.getOrDefault(tokData.getSetCode(), null);
            if (tokensInSet == null) {
                tokensInSet = new ArrayList<>();
                tokDataTokensBySetIndex.put(tokData.getSetCode(), tokensInSet);
            }
            tokensInSet.add(tokData);

            // by class
            searchName = tokData.getFullClassFileName();
            setsList = tokDataClassesIndex.getOrDefault(searchName, "");
            if (!setsList.isEmpty()) {
                setsList += ",";
            }
            setsList += tokData.getSetCode();
            tokDataClassesIndex.put(searchName, setsList);

            // by name
            searchName = tokData.getName();
            setsList = tokDataNamesIndex.getOrDefault(searchName, "");
            if (!setsList.isEmpty()) {
                setsList += ",";
            }
            setsList += tokData.getSetCode();
            tokDataNamesIndex.put(searchName, setsList);
        }

        // CHECK: token's class name convention
        for (Class<? extends TokenImpl> tokenClass : tokenClassesList) {
            if (!tokenClass.getName().endsWith("Token")) {
                String className = extractShortClass(tokenClass);
                warningsList.add("warning, token class must ends with Token: " + className + " from " + tokenClass.getName());
            }
        }

        // CHECK: public class for downloadable tokens
        for (Class<? extends TokenImpl> tokenClass : publicTokens) {
            String fullClass = tokenClass.getName();
            if (!fullClass.startsWith("mage.game.permanent.token.")) {
                String className = extractShortClass(tokenClass);
                errorsList.add("Error: public token must stores in mage.game.permanent.token package: " + className + " from " + tokenClass.getName());
            }
        }

        // CHECK: private class for inner tokens (no needs at all -- all private tokens must be replaced by CreatureToken)
        for (Class<? extends TokenImpl> tokenClass : privateTokens) {
            String className = extractShortClass(tokenClass);
            errorsList.add("Warning: no needs in private tokens, replace it with CreatureToken: " + className + " from " + tokenClass.getName());
        }

        // CHECK: all public tokens must have tok-data (private tokens uses for innner abilities -- no need images for it)
        for (Class<? extends TokenImpl> tokenClass : publicTokens) {
            Token token = (Token) createNewObject(tokenClass);
            if (token == null) {
                // how-to fix:
                // - create empty param
                // - fix error in token's constructor
                errorsList.add("Error: token must have default constructor with zero params: " + tokenClass.getName());
            } else if (tokDataNamesIndex.getOrDefault(token.getName().replace(" Token", ""), "").isEmpty()) {
                if (token instanceof CreatureToken || token instanceof XmageToken) {
                    // ignore custom token builders
                    continue;
                }
                // how-to fix:
                // - public token must be downloadable, so tok-data must contain miss set
                //   (also don't forget to add new set to scryfall download)
                errorsList.add("Error: can't find data in tokens-database.txt for token: " + tokenClass.getName() + " -> " + token.getName());
            }
        }

        // 111.4. A spell or ability that creates a token sets both its name and its subtype(s).
        // If the spell or ability doesn’t specify the name of the token, its name is the same
        // as its subtype(s) plus the word “Token.” Once a token is on the battlefield, changing
        // its name doesn’t change its subtype(s), and vice versa.
        for (Class<? extends TokenImpl> tokenClass : publicTokens) {
            Token token = (Token) createNewObject(tokenClass);
            if (token == null) {
                // error in constructor, see checks above
                continue;
            }

            // CHECK: tokens must have Token word in the name
            if (token.getDescription().startsWith(token.getName() + ", ")
                    || token.getDescription().contains("named " + token.getName())
                    || (token instanceof CreatureToken)
                    || (token instanceof XmageToken)) {
                // ignore some names:
                // - Boo, a legendary 1/1 red Hamster creature token with trample and haste
                // - 1/1 green Insect creature token with flying named Butterfly
                // - custom token builders
            } else {
                if (!token.getName().endsWith("Token")) {
                    errorsList.add("Error: token's name must ends with Token: "
                            + tokenClass.getName() + " - " + token.getName());
                }
            }

            // CHECK: named tokens must not have Token in the name
            if (token.getDescription().contains("named") && token.getName().contains("Token")) {
                // ignore ability text like Return a card named Deathpact Angel from
                if (!token.getDescription().contains("card named")) {
                    errorsList.add("Error: named token must not have Token in the name: "
                            + tokenClass.getName() + " - " + token.getName() + " - " + token.getDescription());
                }
            }
        }

        // CHECK: wrong set codes in tok-data
        tokDataTokensBySetIndex.forEach((setCode, setTokens) -> {
            if (!allSetCodes.contains(setCode)) {
                errorsList.add("error, tokens-database.txt contains unknown set code: "
                        + setCode + " - " + setTokens.stream().map(TokenInfo::getName).collect(Collectors.joining(", ")));
            }
        });

        // CHECK: find possible sets without tokens
        List<Card> cardsList = new ArrayList<>(CardScanner.getAllCards());
        Map<String, List<Card>> setsWithTokens = new HashMap<>();
        for (Card card : cardsList) {
            // must check all card parts (example: Mila, Crafty Companion with Lukka Emblem)
            String allRules = CardUtil.getObjectPartsAsObjects(card)
                    .stream()
                    .map(obj -> (Card) obj)
                    .map(Card::getRules)
                    .flatMap(Collection::stream)
                    .map(r -> r.toLowerCase(Locale.ENGLISH))
                    .collect(Collectors.joining("; "));
            if ((allRules.contains("create") && allRules.contains("token"))
                    || (allRules.contains("get") && allRules.contains("emblem"))) {
                List<Card> sourceCards = setsWithTokens.getOrDefault(card.getExpansionSetCode(), null);
                if (sourceCards == null) {
                    sourceCards = new ArrayList<>();
                    setsWithTokens.put(card.getExpansionSetCode(), sourceCards);
                }
                sourceCards.add(card);
            }
        }
        // set uses tokens, but tok data miss it
        setsWithTokens.forEach((setCode, sourceCards) -> {
            List<TokenInfo> setTokens = tokDataTokensBySetIndex.getOrDefault(setCode, null);
            if (setTokens == null) {
                // it's not a problem -- just find set's cards without real tokens for image tests
                // Possible reasons:
                // - promo sets with cards without tokens (nothing to do with it)
                // - miss set from tok-data (must add new set to tok-data and scryfall download)
                // - wizards miss some paper printed token, see https://www.mtg.onl/mtg-missing-tokens/
                warningsList.add("info, set's cards uses tokens but tok-data haven't it: "
                        + setCode + " - " + sourceCards.stream().map(MageObject::getName).collect(Collectors.joining(", ")));
            } else {
                // Card can be checked on scryfall like "set:set_code oracle:token_name oracle:token"
                // Possible reasons for un-used tokens:
                // - normal use case: tok-data contains wrong token data and must be removed
                // - normal use case: card uses wrong rules text (must contain "create" and "token" words)
                // - rare use case: un-implemented card that uses a token
                setTokens.forEach(token -> {
                    if (token.getName().contains("Plane - ")) {
                        // cards don't put it to the game, so no related cards
                        return;
                    }
                    String needTokenName = token.getName()
                            .replace(" Token", "")
                            .replace("Emblem ", "");
                    // cards with emblems don't use emblem's name, so check it in card name itself (example: Sarkhan, the Dragonspeaker)
                    // also must check all card parts (example: Mila, Crafty Companion with Lukka Emblem)
                    if (sourceCards.stream()
                            .map(CardUtil::getObjectPartsAsObjects)
                            .flatMap(Collection::stream)
                            .map(obj -> (Card) obj)
                            .map(card -> card.getName() + " - " + String.join(", ", card.getRules()))
                            .noneMatch(s -> s.contains(needTokenName))) {
                        warningsList.add("info, tok-data has un-used tokens: "
                                + token.getSetCode() + " - " + token.getName());
                    }
                });
            }
        });
        // tok data have tokens, but cards from set are miss
        tokDataTokensBySetIndex.forEach((setCode, setTokens) -> {
            if (setCode.equals(TokenRepository.XMAGE_TOKENS_SET_CODE)) {
                // ignore reminder tokens
                return;
            }
            if (!setsWithTokens.containsKey(setCode)) {
                // Possible reasons:
                // - outdated set code in tokens database (must be fixed by new set code, another verify check it)
                // - promo set contains additional tokens for main set (it's ok and must be ignored, example: Saproling in E02)
                warningsList.add("warning, tok-data has tokens, but real set haven't cards with it: "
                        + setCode + " - " + setTokens.stream().map(TokenInfo::getName).collect(Collectors.joining(", ")));
            }
        });

        // CHECK: token and class names must be same in all sets
        TokenRepository.instance.getAllByClassName().forEach((className, list) -> {
            // ignore reminder tokens
            Set<String> names = list.stream()
                    .filter(token -> !token.getTokenType().equals(TokenType.XMAGE))
                    .map(TokenInfo::getName)
                    .collect(Collectors.toSet());
            if (names.size() > 1) {
                errorsList.add("error, tokens-database.txt contains different names for same class: "
                        + className + " - " + String.join(", ", names));
            }
        });

        Set<String> usedNames = new HashSet<>();
        TokenRepository.instance.getByType(TokenType.XMAGE).forEach(token -> {
            // CHECK: xmage's tokens must be unique
            // how-to fix: edit TokenRepository->loadXmageTokens
            String needName = String.format("%s.%d", token.getName(), token.getImageNumber());
            if (usedNames.contains(needName)) {
                errorsList.add("error, xmage token's name and image number must be unique: "
                        + token.getName() + " - " + token.getImageNumber());
            } else {
                usedNames.add(needName);
            }

            // CHECK: xmage's tokens must be downloadable
            // how-to fix: edit TokenRepository->loadXmageTokens
            if (token.getDownloadUrl().isEmpty()) {
                errorsList.add("error, xmage token's must have download url: "
                        + token.getName() + " - " + token.getImageNumber());
            }
        });

        // TODO: all sets must have full tokens data in tok file (token in every set)
        // 1. Download scryfall tokens list: https://api.scryfall.com/cards/search?q=t:token
        // 2. Proccess each token with all prints: read "prints_search_uri" field from token data and go to link like
        // https://api.scryfall.com/cards/search?order=set&q=%21%E2%80%9CAngel%E2%80%9D&unique=prints
        // 3. Collect all strings in "set@name"
        // 4. Proccess tokens data and find missing strings from "set@name" list
        printMessages(warningsList);
        printMessages(errorsList);
        if (errorsList.size() > 0) {
            Assert.fail("Found token errors: " + errorsList.size());
        }
    }

    @Test
    public void test_checkMissingPlanesData() {
        Collection<String> errorsList = new ArrayList<>();

        Reflections reflections = new Reflections("mage.");
        Set<Class<? extends Plane>> planesClassesList = reflections.getSubTypesOf(Plane.class);

        // 1. correct class name
        for (Class<? extends Plane> planeClass : planesClassesList) {
            if (!planeClass.getName().endsWith("Plane")) {
                String className = extractShortClass(planeClass);
                errorsList.add("Error: plane class must ends with Plane: " + className + " from " + planeClass.getName());
            }
        }

        // 2. correct package
        for (Class<? extends Plane> planeClass : planesClassesList) {
            String fullClass = planeClass.getName();
            if (!fullClass.startsWith("mage.game.command.planes.")) {
                String className = extractShortClass(planeClass);
                errorsList.add("Error: plane must be stored in mage.game.command.planes package: " + className + " from " + planeClass.getName());
            }
        }

        // 3. correct constructor
        for (Class<? extends Plane> planeClass : planesClassesList) {
            String className = extractShortClass(planeClass);
            Plane plane;
            try {
                plane = (Plane) createNewObject(planeClass);

                // 4. must have type/name
                if (plane.getPlaneType() == null) {
                    errorsList.add("Error: plane must have plane type: " + className + " from " + planeClass.getName());
                }
            } catch (Throwable e) {
                errorsList.add("Error: can't create plane with default constructor: " + className + " from " + planeClass.getName());
            }
        }

        printMessages(errorsList);
        if (errorsList.size() > 0) {
            Assert.fail("Found plane errors: " + errorsList.size());
        }
    }

    @Test
    public void test_checkMissingDungeonsData() {
        Collection<String> errorsList = new ArrayList<>();

        Reflections reflections = new Reflections("mage.");
        Set<Class<? extends Dungeon>> dungeonClassesList = reflections.getSubTypesOf(Dungeon.class);

        // 1. correct class name
        for (Class<? extends Dungeon> dungeonClass : dungeonClassesList) {
            if (!dungeonClass.getName().endsWith("Dungeon")) {
                String className = extractShortClass(dungeonClass);
                errorsList.add("Error: dungeon class must ends with Dungeon: " + className + " from " + dungeonClass.getName());
            }
        }

        // 2. correct package
        for (Class<? extends Dungeon> dungeonClass : dungeonClassesList) {
            String fullClass = dungeonClass.getName();
            if (!fullClass.startsWith("mage.game.command.dungeons.")) {
                String className = extractShortClass(dungeonClass);
                errorsList.add("Error: dungeon must be stored in mage.game.command.dungeons package: " + className + " from " + dungeonClass.getName());
            }
        }

        // 3. correct constructor
        for (Class<? extends Dungeon> dungeonClass : dungeonClassesList) {
            String className = extractShortClass(dungeonClass);
            Dungeon dungeon;
            try {
                dungeon = (Dungeon) createNewObject(dungeonClass);
            } catch (Throwable e) {
                errorsList.add("Error: can't create dungeon with default constructor: " + className + " from " + dungeonClass.getName());
            }
        }

        printMessages(errorsList);
        if (errorsList.size() > 0) {
            Assert.fail("Found dungeon errors: " + errorsList.size());
        }
    }

    @Test
    // TODO: add same images verify for tokens/dungeons and other
    // TODO: add same verify for Speed and other new command objects
    public void test_checkMissingEmblemsData() {
        Collection<String> errorsList = new ArrayList<>();

        // prepare DBs
        CardScanner.scan();

        Reflections reflections = new Reflections("mage.");
        Set<Class<? extends Emblem>> emblemClassesList = reflections.getSubTypesOf(Emblem.class).stream()
                .filter(c -> !c.equals(EmblemOfCard.class)) // ignore emblem card
                .collect(Collectors.toSet());

        // 1. correct class name
        for (Class<? extends Emblem> emblemClass : emblemClassesList) {
            if (!emblemClass.getName().endsWith("Emblem")) {
                String className = extractShortClass(emblemClass);
                errorsList.add("Error: emblem class must ends with Emblem: " + className + " from " + emblemClass.getName());
            }
        }

        // 2. correct package
        for (Class<? extends Emblem> emblemClass : emblemClassesList) {
            String fullClass = emblemClass.getName();
            if (!fullClass.startsWith("mage.game.command.emblems.")) {
                String className = extractShortClass(emblemClass);
                errorsList.add("Error: emblem must be stored in mage.game.command.emblems package: " + className + " from " + emblemClass.getName());
            }
        }

        // 3. correct constructor
        MageObject fakeObject = CardRepository.instance.findCard("Forest").createCard();
        for (Class<? extends Emblem> emblemClass : emblemClassesList) {
            String className = extractShortClass(emblemClass);
            Emblem emblem;
            try {
                emblem = (Emblem) createNewObject(emblemClass);

                // 4. correct tokens-database (image)
                try {
                    emblem.setSourceObjectAndInitImage(fakeObject);
                } catch (Throwable e) {
                    e.printStackTrace();
                    errorsList.add("Error: can't setup emblem's image data - make sure tokens-database.txt has it: " + className + " from " + emblemClass.getName());
                }
            } catch (Throwable e) {
                e.printStackTrace();
                errorsList.add("Error: can't create emblem with default constructor: " + className + " from " + emblemClass.getName());
            }
        }

        printMessages(errorsList);
        if (errorsList.size() > 0) {
            Assert.fail("Found emblem errors: " + errorsList.size());
        }
    }

    @Test
    @Ignore
    // experimental test to find potentially fail conditions with NPE see https://github.com/magefree/mage/issues/13752
    public void test_checkBadConditions() {
        // all conditions in AsThoughEffect must be compatible with empty source param (e.g. must be able to use inside ConditionalAsThoughEffect)
        // see AsThoughEffectType.needAffectedAbility ?
        // 370+ failed conditions
        Collection<String> errorsList = new ArrayList<>();
        Game fakeGame = new FakeGame();
        Ability fakeAbility = new SimpleStaticAbility(new InfoEffect("fake"));

        // TODO: add classes support (see example with tokens and default constructor)?
        Reflections reflections = new Reflections("mage.");
        Set<Class<?>> conditionEnums = reflections.getSubTypesOf(Condition.class)
                .stream()
                .filter(Class::isEnum)
                .sorted(Comparator.comparing(Class::toString))
                .collect(Collectors.toCollection(LinkedHashSet::new));
        for (Class<?> enumClass : conditionEnums) {
            for (Object enumItem : enumClass.getEnumConstants()) {
                // miss watcher will fail in both use cases, but miss ability only one
                String errorOnAbility = "";
                try {
                    ((Condition) enumItem).apply(fakeGame, fakeAbility);
                } catch (Exception e) {
                    errorOnAbility = Arrays.stream(e.getStackTrace())
                            .map(StackTraceElement::toString)
                            .limit(5)
                            .collect(Collectors.joining("\n"));
                }

                String errorOnEmptyAbility = "";
                try {
                    ((Condition) enumItem).apply(fakeGame, null);
                } catch (Exception e) {
                    errorOnEmptyAbility = Arrays.stream(e.getStackTrace())
                            .map(StackTraceElement::toString)
                            .limit(5)
                            .collect(Collectors.joining("\n"));
                }

                if (errorOnAbility.isEmpty() && !errorOnEmptyAbility.isEmpty()) {
                    System.out.println();
                    System.out.println("bad condition " + enumClass.getName() + "\n" + errorOnEmptyAbility);
                    errorsList.add("Error: condition must support empty and non-empty source params: " + enumClass.getName());
                }
            }
        }

        printMessages(errorsList);
        if (!errorsList.isEmpty()) {
            Assert.fail("Found conditions errors: " + errorsList.size());
        }
    }

    private void check(Card card, int cardIndex) {
        MtgJsonCard ref = MtgJsonService.cardFromSet(card.getExpansionSetCode(), card.getName(), card.getCardNumber());
        if (ref != null) {
            if ((card instanceof CardWithSpellOption || card instanceof SpellOptionCard) && ref.layout.equals("reversible_card")) {
                // TODO: Remove when MtgJson updated
                // workaround for reversible omen cards e.g. Bloomvine Regent // Claim Territory // Bloomvine Regent
                // both sides have main card info
                return;
            }
            checkAll(card, ref, cardIndex);
        } else if (!CHECK_ONLY_ABILITIES_TEXT) {
            warn(card, "Can't find card in mtgjson to verify");
        }
    }

    private boolean contains(Collection<String> options, String value) {
        return options != null && options.contains(value);
    }

    private static boolean wasCheckedByAbilityText(MtgJsonCard ref) {
        // ignore already checked cards, so no bloated logs from duplicated cards
        if (checkedNames.contains(ref.getNameAsFace())) {
            return true;
        }
        checkedNames.add(ref.getNameAsFace());
        return false;
    }

    private void checkAll(Card card, MtgJsonCard ref, int cardIndex) {
        if (!CHECK_ONLY_ABILITIES_TEXT) {
            checkCost(card, ref);
            checkPT(card, ref);
            checkLoyalty(card, ref);
            checkDefense(card, ref);
            checkSubtypes(card, ref);
            checkSupertypes(card, ref);
            checkTypes(card, ref);
            checkColors(card, ref);
            checkRarityAndBasicLands(card, ref);
            checkMissingAbilities(card, ref);
            checkWrongSymbolsInRules(card);
            if (CHECK_COPYABLE_FIELDS) {
                checkCardCanBeCopied(card);
            }
        }
        checkWrongAbilitiesText(card, ref, cardIndex, false);
    }

    private void checkColors(Card card, MtgJsonCard ref) {
        if (skipListHaveName(SKIP_LIST_COLOR, card.getExpansionSetCode(), card.getName())) {
            return;
        }

        // TODO: temporary fix - scryfall/mtgjson wrongly add [colors, mana cost] from spell part to main part/card,
        //  example: Ishgard, the Holy See // Faith & Grief
        if (card instanceof CardWithSpellOption && card.isLand()
                || card instanceof SpellOptionCard && ((SpellOptionCard) card).getParentCard().isLand()) {
            return;
        }

        Set<String> expected = new HashSet<>();
        if (ref.colors != null) {
            expected.addAll(ref.colors);
        }

        ObjectColor color = card.getColor(null);

        if (expected.size() != color.getColorCount()
                || (color.isBlack() && !expected.contains("B"))
                || (color.isBlue() && !expected.contains("U"))
                || (color.isGreen() && !expected.contains("G"))
                || (color.isRed() && !expected.contains("R"))
                || (color.isWhite() && !expected.contains("W"))) {
            fail(card, "colors", color + " != " + expected);
        }
    }

    // "copy" fails means that the copy constructor are not correct inside a card.
    // To fix those, try to find the class that did trigger the copy failure, and check
    // that copy() exists, a copy constructor exists, and the copy constructor is right. 
    private void checkCardCanBeCopied(Card card1) {
        Card card2;
        try {
            card2 = card1.copy();
        } catch (Error err) {
            fail(card1, "copy", "throws on copy : " + err.getClass() + " : " + err.getMessage() + " : ");
            return;
        }

        compareClassRecursive(card1, card2, card1, "[Card", 10, new HashSet<>(), true);
    }

    /**
     * @param obj1           first object to compare. Initially the original card.
     * @param obj2           second object to compare. Initially the copy of the original card.
     * @param originalCard   the original card, used to print a nice message on fail.
     * @param msg            the recursively built message to explain what is different.
     * @param maxDepth       the maximum allowed recursion. A safety mesure for the test to end.
     * @param alreadyChecked Map of all Cards obj1 already compared.
     * @param useRecursive   When false, do not recursively compare Cards.
     */
    private void compareClassRecursive(Object obj1, Object obj2, Card originalCard, String msg, int maxDepth,
                                       Set<Card> alreadyChecked, boolean useRecursive) {
        if (obj1 == null && obj2 == null) {
            return;
        } else if (obj1 == null || obj2 == null) {
            fail(originalCard, "copy", "not same class for " + msg + "]");
        } else if (obj1.getClass() != obj2.getClass()) {
            fail(originalCard, "copy", "not same class for " + msg + "<" + obj1.getClass() + ">" + "]");
        } else if (obj1 == obj2) { // for instances mostly
            return;
        } else {
            // Only recurse so much.
            if (maxDepth == 0) {
                return;
            }
            // Only recurse on those objects
            if (obj1 instanceof MageObject || obj1 instanceof Filter || obj1 instanceof Condition || obj1 instanceof Effect
                    || obj1 instanceof Ability || obj1 instanceof Mana || obj1 instanceof Cost || obj1 instanceof DynamicValue
                    || obj1 instanceof Choice || obj1 instanceof TargetPointer) {

                boolean doRecurse = useRecursive;
                if (obj1 instanceof Card) {
                    if (alreadyChecked.contains(obj1)) {
                        if (!doRecurse) {
                            return; // we already checked that obj1 and do not want to recurse. stop there.
                        } else {
                            doRecurse = false;
                        }
                    } else {
                        alreadyChecked.add((Card) obj1);
                    }
                }

                //System.out.println(msg);
                Class class1 = obj1.getClass();
                Class class2 = obj2.getClass();
                do {
                    if (class1 == null && class2 == null) {
                        return;
                    }
                    if (class1 == null || class2 == null) {
                        fail(originalCard, "copy", "not same class for " + msg + "<" + obj1.getClass() + ">" + "]");
                        return;
                    }
                    if (class1.equals(ArrayList.class)) {
                        List list1 = (ArrayList) obj1;
                        List list2 = (ArrayList) obj2;
                        Iterator it1 = list1.iterator();
                        Iterator it2 = list2.iterator();
                        int i = 0;
                        while (it1.hasNext() && it2.hasNext()) {
                            compareClassRecursive(it1.next(), it2.next(), originalCard, msg + "<" + obj1.getClass() + ">" + "[" + i++ + "]", maxDepth - 1, alreadyChecked, useRecursive);
                        }
                        if (it1.hasNext() || it2.hasNext()) {
                            fail(originalCard, "copy", "not same size for (ArrayList) " + msg + "]");
                        }
                        return;
                    }


                    List<Field> ability2Fields = Arrays.stream(class2.getDeclaredFields()).collect(Collectors.toList());

                    // Special fields for CardImpl.class
                    boolean hasSpellAbilityField = false;
                    boolean hasMeldField = false;
                    boolean hasSecondSideCardField = false;
                    // Special fields for AbilityImpl.class
                    boolean hasWatchersField = false;
                    boolean hasModesField = false;

                    int fieldIndex = 0;
                    for (Field field1 : class1.getDeclaredFields()) {
                        Field field2 = ability2Fields.get(fieldIndex);

                        field1.setAccessible(true);
                        field2.setAccessible(true);
                        try {
                            Object value1 = field1.get(obj1);
                            Object value2 = field2.get(obj2);

                            boolean doFieldRecurse = true;
                            if (class1 == CardImpl.class) {
                                if (field1.getName().equals("spellAbility")) {
                                    compareClassRecursive(((CardImpl) obj1).getSpellAbility(), ((CardImpl) obj2).getSpellAbility(), originalCard, msg + "<" + obj1.getClass() + ">" + "::" + field1.getName(), maxDepth - 1, alreadyChecked, doRecurse);
                                    doFieldRecurse = false;
                                    hasSpellAbilityField = true;
                                } else if (field1.getName().equals("meldsToCard")) {
                                    compareClassRecursive(((CardImpl) obj1).getMeldsToCard(), ((CardImpl) obj2).getMeldsToCard(), originalCard, msg + "::" + field1.getName(), maxDepth - 1, alreadyChecked, doRecurse);
                                    doFieldRecurse = false;
                                    hasMeldField = true;
                                } else if (field1.getName().equals("secondSideCard")) {
                                    compareClassRecursive(((CardImpl) obj1).getSecondCardFace(), ((CardImpl) obj2).getSecondCardFace(), originalCard, msg + "::" + field1.getName(), maxDepth - 1, alreadyChecked, doRecurse);
                                    doFieldRecurse = false;
                                    hasSecondSideCardField = true;
                                }
                            }
                            if (class1 == AbilityImpl.class) {
                                if (field1.getName().equals("watchers")) {
                                    // Watchers are only used on initialization, they are not copied.
                                    doFieldRecurse = false;
                                    hasWatchersField = true;
                                }
                                if (field1.getName().equals("modes")) {
                                    //compareClassRecursive(((AbilityImpl) obj1).getModes(), ((AbilityImpl) obj2).getModes(), originalCard, msg + "<" + obj1.getClass() + ">" + "::" + field1.getName(), maxDepth - 1);
                                    compareClassRecursive(((AbilityImpl) obj1).getEffects(), ((AbilityImpl) obj2).getEffects(), originalCard, msg + "<" + obj1.getClass() + ">" + "::" + field1.getName(), maxDepth - 1, alreadyChecked, doRecurse);
                                    doFieldRecurse = false;
                                    hasModesField = true;
                                }
                            }
                            if (doFieldRecurse) {
                                compareClassRecursive(value1, value2, originalCard, msg + "<" + obj1.getClass() + ">" + "::" + field1.getName(), maxDepth - 1, alreadyChecked, doRecurse);
                            }
                        } catch (IllegalArgumentException | IllegalAccessException e) {
                        }
                        fieldIndex++;
                    }

                    // Do check that the expected special fields were encountered.
                    // If those field are no relevant anymore, or were renamed, please modify the matching code
                    // block above on how to loop into those fields.
                    if (class1 == CardImpl.class) {
                        if (!hasSpellAbilityField) {
                            fail(originalCard, "copy", "was expecting a spellAbility field, but found none " + msg + "]");
                        }
                        if (!hasMeldField) {
                            fail(originalCard, "copy", "was expecting a meldsToCard field, but found none " + msg + "]");
                        }
                        if (!hasSecondSideCardField) {
                            fail(originalCard, "copy", "was expecting a secondSideCard field, but found none " + msg + "]");
                        }
                    } else if (class1 == AbilityImpl.class) {
                        if (!hasWatchersField) {
                            fail(originalCard, "copy", "was expecting a watchers field, but found none " + msg + "]");
                        }
                        if (!hasModesField) {
                            fail(originalCard, "copy", "was expecting a modes field, but found none " + msg + "]");
                        }
                    }

                    class1 = class1.getSuperclass();
                    class2 = class2.getSuperclass();
                } while (class1 != Object.class && class1 != null);
            } else if (obj1 instanceof Collection) {
                Collection col1 = (Collection) obj1;
                Collection col2 = (Collection) obj2;
                Iterator it1 = col1.iterator();
                Iterator it2 = col2.iterator();
                int i = 0;
                while (it1.hasNext() && it2.hasNext()) {
                    compareClassRecursive(it1.next(), it2.next(), originalCard, msg + "<" + obj1.getClass() + ">" + "[" + i++ + "]", maxDepth - 1, alreadyChecked, useRecursive);
                }
                if (it1.hasNext() || it2.hasNext()) {
                    fail(originalCard, "copy", "not same size for (Collection) " + msg + "]");
                }
            } else if (obj1 instanceof Map) {
                Map map1 = (Map) obj1;
                Map map2 = (Map) obj2;
                map1.forEach((i, el1) -> {
                    compareClassRecursive(el1, ((Map<?, ?>) obj2).get(i), originalCard, msg + "<" + obj1.getClass() + ">" + ".(" + i + ")", maxDepth - 1, alreadyChecked, useRecursive);
                });
                if (map1.size() != map2.size()) {
                    fail(originalCard, "copy", "not same size for (Map) " + msg + "]");
                }
            }
        }
    }

    private void checkSubtypes(Card card, MtgJsonCard ref) {
        if (skipListHaveName(SKIP_LIST_SUBTYPE, card.getExpansionSetCode(), card.getName())) {
            return;
        }

        List<String> expected = new ArrayList<>(ref.subtypes);

        // fix names (e.g. Urza’s to Urza's)
        for (ListIterator<String> it = expected.listIterator(); it.hasNext(); ) {
            switch (it.next()) {
                case "Urza’s":
                    it.set("Urza's");
                    break;
                case "C’tan":
                    it.set("C'tan");
            }
        }

        if (expected.contains("Time") && expected.contains("Lord")) {
            expected.remove("Time");
            expected.remove("Lord");
            expected.add("Time Lord");
        }

        // Remove subtypes that need to be ignored
        Collection<String> actual = card
                .getSubtype()
                .stream()
                .map(SubType::toString)
                .collect(Collectors.toSet());

        actual.removeIf(subtypesToIgnore::contains);
        expected.removeIf(subtypesToIgnore::contains);

        for (SubType subType : card.getSubtype()) {
            if (subType.isCustomSet()) {
                if (!ref.isFunny) {
                    fail(card, "subtypes", "subtype " + subType + " is marked as \"custom\" but is in an official set");
                }
                continue;
            }
            if (!subType.canGain(card)) {
                String cardTypeString = card
                        .getCardType()
                        .stream()
                        .map(CardType::toString)
                        .reduce((a, b) -> a + " " + b)
                        .orElse("");
                fail(card, "subtypes", "card has subtype "
                        + subType.getDescription() + " (" + subType.getSubTypeSet() + ')'
                        + " that doesn't match its card type(s) (" + cardTypeString + ')');
            }
        }

        if (!eqSet(actual, expected)) {
            fail(card, "subtypes", actual + " != " + expected);
        }
    }

    private void checkSupertypes(Card card, MtgJsonCard ref) {
        if (skipListHaveName(SKIP_LIST_SUPERTYPE, card.getExpansionSetCode(), card.getName())) {
            return;
        }

        Collection<String> expected = ref.supertypes;
        if (!eqSet(card.getSuperType().stream().map(s -> s.toString()).collect(Collectors.toList()), expected)) {
            fail(card, "supertypes", card.getSuperType() + " != " + expected);
        }
    }

    // There are many cards that use the word "target" or "targets" in reference to spells/abilities that target rather than actually themselves having a target.
    // Examples include Wall of Shadows, Psychic Battle, Coalition Honor Guard, Aboleth Spawn, Akroan Crusader, Grip of Chaos, and many more
    Pattern singularTargetRegexPattern = Pattern.compile("\\b(?<!(can|the|that|could|each|single|its|new|spell's) )target\\b");
    Pattern pluralTargetsRegexPattern = Pattern.compile("\\b(?<!(new|the|that|copy|choosing|it|more|spell|or|changing|legal|has) )targets\\b");

    // Note that the check includes reminder text, so any keyword ability with reminder text always included in the card text doesn't need to be added
    // FIN added equip abilities with flavor words, allow for those. There are also cards that affect equip costs or equip abilities, exclude those
    // Technically Enchant should be in this list, but that's added to the SpellAbility in XMage
    // Earthbend is an action word and thus can be anywhere, the rest are keywords that are always first in the line
    Pattern targetKeywordRegexPattern = Pattern.compile("earthbend |^((.*— )?equip(?! cost| abilit)|bestow|partner with|modular|backup)\\b", Pattern.MULTILINE);

    // Checks for targeted reflexive or delayed triggered abilities, ones that only can trigger as a result of another ability
    // and thus have their "when" located after a previous statement (detected by a period or comma followed by a space) instead of the start.
    // Some reflexive triggers (Cemetery Desecrator, Tranquil Frillback) have a modal decision before the word target, need to check across multiple lines of text for those (and . doesn't match newlines)
    // Many delayed triggers only get caught by the recursiveTargetAbilityCheck, if we want to improve that check to be an "and" instead of the current "or", we'll need to add them here
    Pattern indirectTriggerTargetRegexPattern = Pattern.compile("([.,] when)(.|—\\n)+target");

    // Check if the word "target" is inside a quoted ability being granted or of a token (or is using GiveScavengeContinuousEffect)
    // A quoted ability always has a space before the opening quote and never before the closing one, so we can use that to ensure we're only checking inside
    Pattern quotedTargetRegexPattern = Pattern.compile(" \"[^\"]*target|has scavenge");

    // This check looks inside the abilities' effects to try to find a target that's not part of the main ability
    // Examples include reflexive triggers (Ahn-Crop Crasher), delayed triggers (Feral Encounter), ability granting (Acidic Sliver), or tokens with abilities (Dance with Devils)
    // Ideally the indirect/quoted text check and this check would always return the same result, but that would require both better regexes for checking and a lot of card changes
    boolean recursiveTargetObjectCheck(Object obj, int depth) {
        if (depth < 0) {
            return false;
        }
        if (obj instanceof Effect) {
            return recursiveTargetEffectCheck((Effect) obj, depth - 1);
        }
        if (obj instanceof Ability) {
            return recursiveTargetAbilityCheck((Ability) obj, depth - 1);
        }
        if (obj instanceof Token) {
            return ((Token) obj).getAbilities().stream().anyMatch(ability -> recursiveTargetAbilityCheck(ability, depth - 1));
        }
        if (obj instanceof Collection) {
            return ((Collection) obj).stream().anyMatch(x -> recursiveTargetObjectCheck(x, depth - 1));
        }
        return false;
    }

    boolean recursiveTargetEffectCheck(Effect effect, int depth) {
        if (depth < 0) {
            return false;
        }
        return Arrays.stream(effect.getClass().getDeclaredFields())
                .anyMatch(f -> {
                    f.setAccessible(true);
                    try {
                        return recursiveTargetObjectCheck(f.get(effect), depth); // Intentionally not decreasing depth here
                    } catch (IllegalAccessException ex) {
                        throw new RuntimeException(ex); // Should never happen due to setAccessible
                    }
                });
    }

    boolean recursiveTargetAbilityCheck(Ability ability, int depth) {
        if (depth < 0) {
            return false;
        }
        Collection<Mode> modes = ability.getModes().values();
        return modes.stream().flatMap(mode -> mode.getTargets().stream()).anyMatch(target -> !target.isNotTarget())
                || ability.getTargetAdjuster() != null
                || modes.stream().flatMap(mode -> mode.getEffects().stream()).anyMatch(effect -> recursiveTargetEffectCheck(effect, depth - 1));
    }

    private void checkMissingAbilities(Card card, MtgJsonCard ref) {
        if (skipListHaveName(SKIP_LIST_MISSING_ABILITIES, card.getExpansionSetCode(), card.getName())) {
            return;
        }

        // search missing abilities from card source
        if (ref.text == null || ref.text.isEmpty()) {
            return;
        }

        String refLowerText = ref.text.toLowerCase(Locale.ENGLISH);
        String cardLowerText = String.join("\n", card.getRules()).toLowerCase(Locale.ENGLISH);

        // special check: kicker ability must be in rules
        if (card.getAbilities().containsClass(MultikickerAbility.class) && card.getRules().stream().noneMatch(rule -> rule.contains("Multikicker"))) {
            fail(card, "abilities", "card have Multikicker ability, but missing it in rules text");
        }

        // special check: Auras need to have enchant ability added
        if (card.hasSubtype(SubType.AURA, null) && !card.getAbilities().containsClass(EnchantAbility.class)) {
            fail(card, "abilities", "card is an Aura but is missing this.addAbility(EnchantAbility)");
        }

        // special check: Sagas need to have saga ability added
        if (card.hasSubtype(SubType.SAGA, null) && !card.getAbilities().containsClass(SagaAbility.class)) {
            fail(card, "abilities", "card is a Saga but is missing this.addAbility(SagaAbility)");
        }

        // special check: backup ability should be set up correctly
        if (card.getAbilities().containsClass(BackupAbility.class) && CardUtil.castStream(card.getAbilities().stream(), BackupAbility.class).noneMatch(BackupAbility::hasAbilities)) {
            fail(card, "abilities", "card has backup but is missing this.addAbility(backupAbility)");
        }

        // special check: DFC main card should not have abilities
        if (card instanceof DoubleFacedCardHalf && !card.getMainCard().getInitAbilities().isEmpty()) {
            fail(card, "abilities", "transforming double-faced card should not have abilities on the main card");
        }

        // TODO: remove after transform ability removed
        // special check: new DFC implementation should not have transform ability
        if (card instanceof DoubleFacedCardHalf && card.getAbilities().containsClass(TransformAbility.class)
                && !card.getAbilities().containsClass(DayboundAbility.class)
                && !card.getAbilities().containsClass(CraftAbility.class)
                && !card.getAbilities().containsClass(SiegeAbility.class)) {
            fail(card, "abilities", "new transforming double-faced card should not have transform ability");
        }

        // special check: Werewolves front ability should only be on front and vice versa
        if (card.getAbilities().containsClass(WerewolfFrontTriggeredAbility.class) && (card.isNightCard() || (card instanceof DoubleFacedCardHalf && ((DoubleFacedCardHalf) card).isBackSide()))) {
            fail(card, "abilities", "card is a back face werewolf with a front face ability");
        }
        if (card.getAbilities().containsClass(WerewolfBackTriggeredAbility.class) && (!card.isNightCard() && (card instanceof DoubleFacedCardHalf && !((DoubleFacedCardHalf) card).isBackSide()))) {
            fail(card, "abilities", "card is a front face werewolf with a back face ability");
        }

        // special check: transform ability in TDFC should only be on front and vice versa
        if (card.getSecondCardFace() != null && !card.isNightCard() && !card.getAbilities().containsClass(TransformAbility.class)) {
            fail(card, "abilities", "double-faced cards should have transform ability on the front");
        }
        if (card.getSecondCardFace() != null && card.isNightCard() && card.getAbilities().containsClass(TransformAbility.class)) {
            fail(card, "abilities", "double-faced cards should not have transform ability on the back");
        }

        // special check: back side in TDFC must be only night card
        if (card.getSecondCardFace() != null && !card.getSecondCardFace().isNightCard()) {
            fail(card, "abilities", "the back face of a double-faced card should be nightCard = true");
        }

        // special check: siege ability must be used in double faced cards only
        if (card.getAbilities().containsClass(SiegeAbility.class) && (card.getSecondCardFace() == null && (card instanceof DoubleFacedCardHalf && ((DoubleFacedCardHalf) card).getOtherSide() == null))) {
            fail(card, "abilities", "miss second side settings in card with siege ability");
        }

        // special check: legendary spells need to have legendary spell ability
        if (card.isLegendary() && !card.isPermanent() && !card.getAbilities().containsClass(LegendarySpellAbility.class)) {
            fail(card, "abilities", "legendary nonpermanent cards need to have LegendarySpellAbility");
        }

        // special check: mutate is not supported yet, so must be removed from sets
        if (card.getAbilities().containsClass(MutateAbility.class)) {
            // how-to fix: add that code at the end of the set
            // cards.removeIf(card -> HIDE_MUTATE_CARDS && MUTATE_CARD_NAMES.contains(card.getName()));
            fail(card, "abilities", "mutate cards aren't implemented and shouldn't be available");
        }

        // special check: some new creature's ETB must use When this creature enters instead When {this} enters
        if (EntersBattlefieldTriggeredAbility.ENABLE_TRIGGER_PHRASE_AUTO_FIX) {
            if (etbTriggerPhrases.isEmpty()) {
                etbTriggerPhrases.addAll(EntersBattlefieldTriggeredAbility.getPossibleTriggerPhrases());
                Assert.assertTrue(etbTriggerPhrases.get(0).startsWith("when"));
            }
            if (refLowerText.contains("when")) {
                for (String needTriggerPhrase : etbTriggerPhrases) {
                    if (refLowerText.contains(needTriggerPhrase) && !cardLowerText.contains(needTriggerPhrase)) {
                        fail(card, "abilities", "wrong creature's ETB trigger phrase, must use: " + needTriggerPhrase);
                    }
                }
            }
        }

        // special check: wrong dies triggers (there are also a runtime check on wrong usage, see isInUseableZoneDiesTrigger)
        Set<String> ignoredCards = new HashSet<>();
        ignoredCards.add("Caller of the Claw");
        ignoredCards.add("Boneyard Scourge");
        ignoredCards.add("Fell Shepherd");
        ignoredCards.add("Massacre Girl");
        ignoredCards.add("Infested Thrinax");
        ignoredCards.add("Xira, the Golden Sting");
        ignoredCards.add("Mawloc");
        ignoredCards.add("Crack in Time");
        ignoredCards.add("Mysterious Limousine");
        ignoredCards.add("Graceful Antelope");
        ignoredCards.add("Portcullis");
        List<String> ignoredAbilities = new ArrayList<>();
        ignoredAbilities.add("roll"); // roll die effects
        ignoredAbilities.add("with \"When"); // token creating effects
        ignoredAbilities.add("gains \"When"); // token creating effects
        ignoredAbilities.add("and \"When"); // token creating effects
        ignoredAbilities.add("it has \"When"); // token creating effects
        ignoredAbilities.add("beginning of your end step"); // step triggers
        ignoredAbilities.add("beginning of each end step"); // step triggers
        ignoredAbilities.add("beginning of combat"); // step triggers
        if (!ignoredCards.contains(card.getName())) {
            for (Ability ability : card.getAbilities()) {
                TriggeredAbility triggeredAbility = ability instanceof TriggeredAbility ? (TriggeredAbility) ability : null;
                if (triggeredAbility == null) {
                    continue;
                }

                // ignore exile effects
                // example 1: exile up to one other target nonland permanent until Constable of the Realm leaves the battlefield.
                if (ability.getAllEffects().stream().anyMatch(e -> e instanceof ExileUntilSourceLeavesEffect)) {
                    continue;
                }
                // example 2: When Hostage Taker enters the battlefield, exile another target artifact or creature until Hostage Taker leaves the battlefield
                if (ability instanceof EntersBattlefieldTriggeredAbility) {
                    continue;
                }


                // search and check dies related abilities
                // remove reminder text
                String rules = triggeredAbility
                        .getRule()
                        .replaceAll("(?i) <i>\\(.+\\)</i>", "")
                        .replaceAll("(?i) \\(.+\\)", "");
                if (ignoredAbilities.stream().anyMatch(rules::contains)) {
                    continue;
                }
                boolean isDiesAbility = rules.contains("die ")
                        || (rules.contains("dies ") && !rules.contains("dies this turn"))
                        || rules.contains("die,")
                        || rules.contains("dies,");
                boolean isPutToGraveAbility = rules.contains("put into")
                        && rules.contains("graveyard")
                        && rules.contains("from the battlefield");
                boolean isLeavesBattlefield = rules.contains("leaves the battlefield") && !rules.contains("until {this} leaves the battlefield");
                if (triggeredAbility.isLeavesTheBattlefieldTrigger()) {
                    // TODO: add check for wrongly enabled settings too?
                } else {
                    if (isDiesAbility || isPutToGraveAbility || isLeavesBattlefield) {
                        fail(card, "abilities", "dies related trigger must use setLeavesTheBattlefieldTrigger(true) and possibly override isInUseableZone - "
                                + triggeredAbility.getClass().getSimpleName());
                    }
                }
            }
        }

        // special check: duplicated words in ability text (wrong target/filter usage)
        // example: You may exile __two two__ blue cards
        // possible fixes:
        //  - remove numbers from filter's text
        //  - use target.getDescription() in ability instead target.getTargetName()
        for (String rule : card.getRules()) {
            for (String doubleNumber : doubleWords) {
                if (rule.toLowerCase(Locale.ENGLISH).contains(doubleNumber)) {
                    fail(card, "abilities", "duplicated numbers/words: " + rule);
                }
            }
        }


        // special check: wrong targeted ability
        // Checks that no ability targets use withNotTarget (use OneShotNonTargetEffect if it's a choose effect)
        // Checks that, if the text contains the word target, the ability does have a target.
        // - In cases involving a target in a reflexive trigger or token or other complex situation, it assumes that it's fine
        // - There are two versions of this complexity check, either can trigger: one on card text, one that uses Java reflection to inspect the ability's effects.
        String[] excludedCards = {"Lodestone Bauble", // Needs to choose a player before targets are selected
                "Blink", // Current XMage code does not correctly support non-consecutive chapter effects, duplicates effects as a workaround
                "Artifact Ward"}; // This card is just implemented wrong, but would need significant work to fix
        if (Arrays.stream(excludedCards).noneMatch(x -> x.equals(ref.name))) {
            for (Ability ability : card.getAbilities()) {
                boolean foundNotTarget = ability.getModes().values().stream()
                        .flatMap(mode -> mode.getTargets().stream()).anyMatch(Target::isNotTarget);
                if (foundNotTarget) {
                    fail(card, "abilities", "notTarget should not be used as ability target, should be inside ability effect");
                }
                String abilityText = ability.getRule().toLowerCase(Locale.ENGLISH);
                boolean needTargetedAbility = singularTargetRegexPattern.matcher(abilityText).find() || pluralTargetsRegexPattern.matcher(abilityText).find() || targetKeywordRegexPattern.matcher(abilityText).find();
                boolean recursiveAbilityText = indirectTriggerTargetRegexPattern.matcher(abilityText).find() || quotedTargetRegexPattern.matcher(abilityText).find();

                boolean foundTargetedAbility = recursiveTargetAbilityCheck(ability, 0);
                boolean recursiveAbility = recursiveTargetAbilityCheck(ability, 4);

                if (needTargetedAbility && !(foundTargetedAbility || recursiveAbilityText || recursiveAbility)
                        && card.getAbilities().stream().noneMatch(x -> x instanceof LevelUpAbility)) { // Targeting Level Up abilities' text is put in the power-toughness setting effect
                    fail(card, "abilities", "wrong target settings (must be targeted, but is not):" + ability.getClass().getSimpleName());
                }
                if (!needTargetedAbility && foundTargetedAbility
                        && !(ability instanceof SpellAbility && abilityText.equals("") && card.getSubtype().contains(SubType.AURA)) // Auras' SpellAbility targets, not the EnchantAbility
                        && !(ability instanceof SpellAbility && (recursiveTargetAbilityCheck(card.getSpellAbility(), 0))) // SurgeAbility is a modified copy of the main SpellAbility, so it targets
                        && !(ability instanceof SpellTransformedAbility)) { // DisturbAbility targets if the backside aura targets
                    fail(card, "abilities", "wrong target settings (targeted ability found but no target in text):" + ability.getClass().getSimpleName());
                }
            }
            // Also check that the reference text and the final ability text have the same number of "target"
            String preparedRefText = refLowerText.replaceAll("\\([^)]+\\)", ""); // Remove reminder text
            int refTargetCount = (preparedRefText.length() - preparedRefText.replace("target", "").length());
            String preparedRuleText = cardLowerText.replaceAll("\\([^)]+\\)", "");
            if (!ref.subtypes.contains("Adventure") && !ref.subtypes.contains("Omen")) {
                preparedRuleText = preparedRuleText.replaceAll("^(adventure|omen).*", "");
            }
            int cardTargetCount = (preparedRuleText.length() - preparedRuleText.replace("target", "").length());
            if (refTargetCount != cardTargetCount) {
                fail(card, "abilities", "target count text discrepancy: " + (refTargetCount / 6) + " in reference but " + (cardTargetCount / 6) + " in card.");
            }
        }

        // special check: missing or wrong ability/effect rules hint
        Map<Class, String> ruleHints = new HashMap<>();
        ruleHints.put(FightTargetsEffect.class, "Each deals damage equal to its power to the other");
        ruleHints.put(MenaceAbility.class, "can't be blocked except by two or more");
        ruleHints.put(ScryEffect.class, "Look at the top card of your library. You may put that card on the bottom");
        ruleHints.put(EquipAbility.class, "Equip only as a sorcery.");
        ruleHints.put(WardAbility.class, "becomes the target of a spell or ability an opponent controls");
        ruleHints.put(ProliferateEffect.class, "Choose any number of permanents and/or players, then give each another counter of each kind already there.");
        for (Class objectClass : ruleHints.keySet()) {
            String needText = ruleHints.get(objectClass);
            // ability/effect must have description or not
            boolean needHint = ref.text.contains(needText);
            boolean haveHint = card.getRules().stream().anyMatch(rule -> rule.contains(needText));
            if (needHint != haveHint) {
                warn(card, "card have " + objectClass.getSimpleName() + " but hint is wrong (it must be " + (needHint ? "enabled" : "disabled") + ")");
            }
        }

        // special check: missing card hints like designation
        Map<Class, String> cardHints = new HashMap<>();
        cardHints.put(CitysBlessingHint.class, "city's blessing");
        cardHints.put(MonarchHint.class, "the monarch");
        cardHints.put(InitiativeHint.class, "the initiative");
        cardHints.put(CurrentDungeonHint.class, "venture into");
        for (Class hintClass : cardHints.keySet()) {
            String lookupText = cardHints.get(hintClass);
            boolean needHint = ref.text.contains(lookupText);
            if (needHint) {
                boolean haveHint = card.getAbilities()
                        .stream()
                        .flatMap(ability -> ability.getHints().stream())
                        .anyMatch(h -> h.getClass().equals(hintClass));
                if (!haveHint) {
                    fail(card, "abilities", "miss card hint: " + hintClass.getSimpleName());
                }
            }
        }

        // special check: equip abilities must have controlled predicate due rules
        List<EquipAbility> equipAbilities = card.getAbilities()
                .stream()
                .filter(a -> a instanceof EquipAbility)
                .map(a -> (EquipAbility) a)
                .collect(Collectors.toList());
        equipAbilities.forEach(a -> {
            List<Predicate> allPredicates = new ArrayList<>();
            a.getTargets().forEach(t -> Predicates.collectAllComponents(t.getFilter().getPredicates(), t.getFilter().getExtraPredicates(), allPredicates));
            boolean hasControlledFilter = allPredicates
                    .stream()
                    .filter(p -> p instanceof TargetController.ControllerPredicate)
                    .map(p -> ((TargetController.ControllerPredicate) p).getController())
                    .anyMatch(tc -> tc.equals(TargetController.YOU));
            if (!hasControlledFilter) {
                fail(card, "abilities", "card has equip ability, but it doesn't use controllered filter - " + a.getRule());
            }
        });

        // special check: target tags must be used for all targets and starts with 1
        card.getAbilities().stream().filter(a -> a.getTargets().size() >= 2).forEach(a -> {
            Set<Integer> tags = a.getTargets().stream().map(Target::getTargetTag).collect(Collectors.toSet());
            if (tags.size() == 1 && tags.stream().findFirst().get().equals(0)) {
                // no tags usage
                return;
            }
            if (tags.size() != a.getTargets().size() || (tags.size() > 1 && tags.contains(0))) {
                // how-to fix: make sure each target has it's own target tag like 1 and 2 (don't use 0 because it's default)
                fail(card, "abilities", "wrong target tags: miss tag in one of the targets, current list: " + tags);
            }
        });

        // spells have only 1 ability
        if (card.isInstantOrSorcery()) {
            return;
        }

        // additional cost go to 1 ability
        if (refLowerText.startsWith("as an additional cost to cast")) {
            return;
        }

        // must have 1+ abilities all the time (to cast)
        if (card.getAbilities().toArray().length <= 1) { // all cards have 1 inner ability to cast
            fail(card, "abilities", "card's abilities is empty, but ref have text");
        }
    }

    private static final String[] wrongSymbols = {"’", "“", "”"};

    private void checkWrongSymbolsInRules(Card card) {
        for (String s : wrongSymbols) {
            if (card.getName().contains(s)) {
                fail(card, "card name", "card's name contains restricted symbol " + s);
            }
        }

        for (String rule : card.getRules()) {
            for (String s : wrongSymbols) {
                if (rule.contains(s)) {
                    fail(card, "rules", "card's rules contains restricted symbol " + s);
                }
            }
            if (rule.contains("&mdash ")) {
                fail(card, "rules", "card's rules contains restricted test [&mdash ] instead [&mdash;]");
            }
        }
    }

    private void checkLegalityFormats(Card card, MtgJsonCard ref) {
        if (skipListHaveName("LEGALITY", card.getExpansionSetCode(), card.getName())) {
            return;
        }

        // TODO: add legality checks (by sets and cards, by banned)
    }

    private static final List<SubType> selfRefNamedSubtypes = Arrays.asList(
            SubType.EQUIPMENT,
            SubType.VEHICLE,
            SubType.SPACECRAFT,
            SubType.AURA,
            SubType.CLASS,
            SubType.SAGA,
            SubType.SIEGE
    );

    private static String applySelfReference(String rule, MageObject mageObject, Game game) {
        return rule
                .replace("{this}", getCardSelfReference(mageObject, game))
                .replace(". this", ". This")
                .replace("\nthis", "\nThis")
                .replace("-this", "-This")
                .replace(": this", ": This")
                .replace("&bull this", "&bull This")
                .replace("&mdash; this", "&mdash; This")
                .replace("&mdash;this", "&mdash;This")
                .replace("- this", "- This");
    }

    /**
     * Returns the description of the card for rules text that references itself.
     * Applies to abilities that function only on the battlefield.
     * Does not account for every exception.
     * <a href="https://scryfall.com/blog/errata-notice-aetherdrift-231">Details here</a>
     */
    private static String getCardSelfReference(MageObject mageObject, Game game) {
        if (!mageObject.isPermanent(game)) {
            return mageObject.getName();
        }
        if (mageObject.isPlaneswalker(game)) {
            // try to ref by planeswalker name which is subtype
            return mageObject
                    .getSubtype(game)
                    .stream()
                    .filter(SubType.getPlaneswalkerTypes()::contains)
                    .findFirst()
                    .map(SubType::getDescription)
                    .orElse(mageObject.getName());
        }
        if (mageObject.isLegendary(game)) {
            // Generate shortname for legendary permanent (other than planeswalker)
            List<String> parts = Arrays.asList(mageObject.getName().split("(, | of the )"));
            if (parts.size() > 1) {
                return parts.get(0);
            } else {
                return mageObject.getName();
            }
        }
        if (mageObject.isCreature(game)) {
            return "this creature";
        }
        for (SubType subType : selfRefNamedSubtypes) {
            if (mageObject.hasSubtype(subType, game)) {
                return "this " + subType.getDescription();
            }
        }
        if (mageObject.isLand(game)) {
            return "this land";
        }
        if (mageObject.isBattle(game)) {
            return "this battle";
        }
        if (mageObject.isEnchantment(game)) {
            return "this enchantment";
        }
        if (mageObject.isArtifact(game)) {
            return "this artifact";
        }
        return "this permanent";
    }

    private String prepareRule(Card card, String rule) {
        // remove and optimize rule text for analyze
        String newRule = rule;

        // remove reminder text
        newRule = newRule.replaceAll("(?i) <i>\\(.+\\)</i>", "");
        newRule = newRule.replaceAll("(?i) \\(.+\\)", "");

        // fix specifically for mana abilities
        if (newRule.startsWith("({T}: Add")) {
            newRule = newRule
                    .replace("(", "")
                    .replace(")", "");
        }

        // replace special text and symbols
        newRule = applySelfReference(newRule, card, null)
                .replace("−", "-")
                .replace("—", "-")
                .replace("&mdash;", "-");

        // remove html marks
        newRule = newRule
                .replace("<i>", "")
                .replace("</i>", "");

        newRule = CardNameUtil.normalizeCardName(newRule);

        return CardUtil.getTextWithFirstCharUpperCase(newRule.trim());
    }

    @Test
    public void test_showCardInfo() {
        // debug only: show direct card rules from a class file without db-recreate
        //  - search by card name: Spark Double
        //  - search by class name from set: SparkDouble
        //  - search by class name from non-set: SparkDoubleFixedV1;SparkDoubleFixedV2
        //  - multiple searches: name1;class2;name3
        String cardSearches = "Spark Double;AbandonedSarcophagus";

        // command line support, e.g. check currently opened file
        // compatible IDEs: IntelliJ IDEA, Visual Studio Code - see instructions in https://github.com/magefree/mage/wiki/Setting-up-your-Development-Environment
        // example cmd: mvn install test "-Dxmage.showCardInfo=${fileBasenameNoExtension}" "-Dsurefire.failIfNoSpecifiedTests=false" "-Dxmage.build.tests.treeViewRunnerShowAllLogs=true" -Dtest=VerifyCardDataTest#test_showCardInfo
        if (System.getProperty("xmage.showCardInfo") != null) {
            cardSearches = System.getProperty("xmage.showCardInfo");
        }

        // prepare DBs
        CardScanner.scan();
        MtgJsonService.cards();

        Arrays.stream(cardSearches.split(";")).forEach(searchName -> {
            // original card
            searchName = searchName.trim();
            String searchClass = String.format("mage.cards.%s.%s",
                    searchName.substring(0, 1).toLowerCase(Locale.ENGLISH),
                    searchName);

            String foundCardName = "";
            String foundClassName = "";

            // search by name
            CardInfo cardInfo = CardRepository.instance.findCard(searchName);
            if (cardInfo != null) {
                foundCardName = cardInfo.getName();
                foundClassName = cardInfo.getClassName();
            }

            // search by class from set
            if (foundClassName.isEmpty()) {
                cardInfo = CardRepository.instance.findCardsByClass(searchClass)
                        .stream()
                        .findFirst()
                        .orElse(null);
                if (cardInfo != null) {
                    foundCardName = cardInfo.getName();
                    foundClassName = cardInfo.getClassName();
                }
            }

            // search by class from non-set (must store in mage.cards.* package)
            if (foundClassName.isEmpty()) {
                Reflections reflections = new Reflections(searchClass);
                try {
                    Set<Class<? extends CardImpl>> founded = reflections.getSubTypesOf(CardImpl.class);
                    if (!founded.isEmpty()) {
                        foundClassName = founded.stream().findFirst().get().getName();
                        foundCardName = searchClass;
                    }
                } catch (Exception e) {
                    if (!e.getMessage().contains("SubTypesScanner was not configured")) {
                        // unknown error
                        throw e;
                    }
                }
            }

            if (foundClassName.isEmpty()) {
                Assert.fail("Can't find card by name or class: " + searchName);
            }

            CardSetInfo testSet = new CardSetInfo(foundCardName, "test", "123", Rarity.COMMON);
            Card card = CardImpl.createCard(foundClassName, testSet);
            Assert.assertNotNull("Card can't be loaded: " + foundClassName, card);

            System.out.println();
            System.out.println(card.getName() + " " + card.getManaCost().getText());
            if (card instanceof CardWithSpellOption) {
                // format to print main card then spell card
                card.getInitAbilities().getRules().forEach(this::printAbilityText);
                ((CardWithSpellOption) card).getSpellCard().getAbilities().getRules().forEach(r -> printAbilityText(r.replace("&mdash; ", "\n")));
            } else if (card instanceof SplitCard || card instanceof ModalDoubleFacedCard) {
                card.getAbilities().getRules().forEach(this::printAbilityText);
            } else {
                card.getRules().forEach(this::printAbilityText);
            }

            // ref card
            System.out.println();
            MtgJsonCard refMain = MtgJsonService.card(card.getName());
            MtgJsonCard refSpell = null;
            if (card instanceof CardWithSpellOption) {
                refSpell = MtgJsonService.card(((CardWithSpellOption) card).getSpellCard().getName());
            }
            if (refMain == null) {
                refMain = MtgJsonService.cardByClassName(foundClassName);
            }
            if (refMain != null) {
                System.out.println("ref: " + refMain.getNameAsFace() + " " + refMain.manaCost);
                System.out.println(refMain.text);
                if (refSpell != null) {
                    System.out.println(refSpell.getNameAsFace() + " " + refSpell.manaCost);
                    System.out.println(refSpell.text);
                }
            } else {
                System.out.println("WARNING, can't find mtgjson ref for " + card.getName());
            }

            // additional check to simulate diff in rules
            if (refMain != null) {
                checkWrongAbilitiesText(card, refMain, 0, true);
            } else if (refSpell != null) {
                checkWrongAbilitiesText(((CardWithSpellOption) card).getSpellCard(), refSpell, 0, true);
            }
        });
    }

    private void printAbilityText(String text) {
        text = text.replace("<br>", "\n");
        System.out.println(text);
    }

    private static boolean compareText(String cardText, String refText, String name) {
        return cardText.equals(refText)
                || cardText.replace(name, name.split(", ")[0])
                .equals(refText.replace(name, name.split(", ")[0]))
                || cardText.replace(name, name.split(" ")[0])
                .equals(refText.replace(name, name.split(" ")[0]));
    }

    private static boolean checkForEffect(Card card, Class<? extends Effect> effectClazz) {
        return card.getAbilities()
                .stream()
                .map(Ability::getModes)
                .map(LinkedHashMap::values)
                .flatMap(Collection::stream)
                .map(Mode::getEffects)
                .flatMap(Collection::stream)
                .anyMatch(effectClazz::isInstance);
    }

    private void checkWrongAbilitiesTextStart() {
        if (FULL_ABILITIES_CHECK_SET_CODES.isEmpty()) {
            return;
        }
        System.out.println("Ability text checks started for " + FULL_ABILITIES_CHECK_SET_CODES);
        wrongAbilityStatsTotal = 0;
        wrongAbilityStatsGood = 0;
        wrongAbilityStatsBad = 0;
    }

    private void checkWrongAbilitiesTextEnd() {
        if (FULL_ABILITIES_CHECK_SET_CODES.isEmpty()) {
            return;
        }

        // TODO: implement tests result/stats by github actions to show in check message compared to prev version
        System.out.println();
        System.out.printf("Stats for %d cards checked for abilities text:%n", wrongAbilityStatsTotal);
        System.out.printf(" - Cards with correct text:  %5d (%.2f)%n", wrongAbilityStatsGood, wrongAbilityStatsGood * 100.0 / wrongAbilityStatsTotal);
        System.out.printf(" - Cards with text errors:   %5d (%.2f)%n", wrongAbilityStatsBad, wrongAbilityStatsBad * 100.0 / wrongAbilityStatsTotal);
        System.out.println();
    }

    private void checkWrongAbilitiesText(Card card, MtgJsonCard ref, int cardIndex, boolean forceToCheck) {
        // checks missing or wrong text
        if (!forceToCheck && !FULL_ABILITIES_CHECK_SET_CODES.equals("*") && !FULL_ABILITIES_CHECK_SET_CODES.contains(card.getExpansionSetCode())) {
            return;
        }
        if (wasCheckedByAbilityText(ref)) {
            return;
        }

        if (ref.text == null || ref.text.isEmpty()) {
            return;
        }

        wrongAbilityStatsTotal++;
        String refText = ref.text;
        // planeswalker fix [-7]: xxx
        refText = refText.replaceAll("\\[([\\−\\+]?\\d*)\\]\\: ", "$1: ").replaceAll("\\[\\−X\\]\\: ", "-X: ");

        // evergreen keyword fix
        for (String s : refText.replaceAll(" \\(.+?\\)", "").split("[\\$\\\n]")) {
            if (Arrays
                    .stream(s.split("[,;] "))
                    .map(String::toLowerCase)
                    .allMatch(VerifyCardDataTest::evergreenCheck)) {
                String replacement = Arrays
                        .stream(s.split("[,;] "))
                        .map(CardUtil::getTextWithFirstCharUpperCase)
                        .collect(Collectors.joining("\n"));
                refText = refText.replace(s, replacement);
            }
        }
        // modal spell fix
        if (refText.contains("•")) {
            refText = refText
                    .replace("—\n•", " —\n•")
                    .replace("  —", " —")
                    .replace("—\n•", "-<br>&bull ")
                    .replace("\n•", "<br>&bull ");
            refText += "<br>";
            refText = refText.replace("<br>", "\n");
        }

        // remove unnecessary reminder text
        refText = refText.replaceAll("^\\(.+(can be paid with|ransforms from|represents).+\\)\n", "");

        // mana ability fix
        // Current implementation makes one Activated Ability per kind of color.
        // We split such abilities in the reference text.
        // For instance "{T}: Add {G} or {W}."
        //      becomes "{T}: Add {G}.\n{T}: Add {W}."
        //
        // The regex down handle more complex situations.
        refText = splitManaAbilities(refText);

        // cycling fix
        // Current implementation makes one CyclingAbility per quality,
        // We split such abilities in the reference text.
        //
        // For instance "Swampcycling {2}, mountaincycling {2}"
        //      becomes "Swampcycling {2}\nMountaincycling {2}"
        refText = splitCyclingAbilities(refText);

        // ref text can contain dirty spaces after some text remove/fix, example: anchor words in Struggle for Project Purity
        refText = refText.replaceAll(" +", " ");

        String[] refRules = refText.split("[\\$\\\n]"); // ref card's abilities can be splited by \n or $ chars
        for (int i = 0; i < refRules.length; i++) {
            refRules[i] = prepareRule(card, refRules[i]);
        }

        if (ref.subtypes.contains("Adventure")) {
            for (int i = 0; i < refRules.length; i++) {
                refRules[i] = "Adventure " +
                        ref.types.get(0) + " - " +
                        ref.faceName + ' ' +
                        ref.manaCost + " - " +
                        refRules[i];
            }
        }
        if (ref.subtypes.contains("Omen")) {
            for (int i = 0; i < refRules.length; i++) {
                refRules[i] = "Omen " +
                        ref.types.get(0) + " - " +
                        ref.faceName + ' ' +
                        ref.manaCost + " - " +
                        refRules[i];
            }
        }

        String[] cardRules = card
                .getRules()
                .stream()
                .filter(s -> !(card instanceof CardWithSpellOption) || !(s.startsWith("Adventure ") || s.startsWith("Omen ")))
                .collect(Collectors.joining("\n"))
                .replace("<br>", "\n")
                .replace("<br/>", "\n")
                .replace("<b>", "")
                .replace("</b>", "")
                .split("[\\$\\\n]");
        for (int i = 0; i < cardRules.length; i++) {
            cardRules[i] = prepareRule(card, cardRules[i]);
        }

        boolean isFine = true;
        for (int i = 0; i < cardRules.length; i++) {
            if (cardRules[i].startsWith("Use the Special button")) {
                // This is a rules text for GUI implication like Quenchable Fire
                cardRules[i] = "+ " + cardRules[i];
                continue;
            }

            boolean isAbilityFounded = false;
            for (int j = 0; j < refRules.length; j++) {
                String refRule = refRules[j];
                if (compareText(cardRules[i], refRule, card.getName())) {
                    cardRules[i] = "+ " + cardRules[i];
                    refRules[j] = "+ " + refRules[j];
                    isAbilityFounded = true;
                    break;
                }
            }

            if (!isAbilityFounded && cardRules[i].length() > 0) {
                isFine = false;
                if (!CHECK_ONLY_ABILITIES_TEXT) {
                    warn(card, "card ability can't be found in ref [" + card.getName() + ": " + cardRules[i] + "]");
                }
                cardRules[i] = "- " + cardRules[i];
            }
        }

        // mark ref rules as unknown
        for (int j = 0; j <= refRules.length - 1; j++) {
            String refRule = refRules[j];
            if (!refRule.startsWith("+ ")) {
                isFine = false;
                refRules[j] = "- " + refRules[j];
            }
        }

        if (isFine) {
            wrongAbilityStatsGood++;
        } else {
            wrongAbilityStatsBad++;
        }

        // extra message for easy checks
        if (forceToCheck || !isFine) {
            System.out.println();

            System.out.println((isFine ? "Good" : "Wrong") + " card " + cardIndex + ": " + card.getName());
            Arrays.sort(cardRules);
            for (String s : cardRules) {
                System.out.println(s);
            }

            System.out.println("ref:");
            Arrays.sort(refRules);
            for (String s : refRules) {
                System.out.println(s);
            }

            System.out.println();
        }
    }

    private String splitCyclingAbilities(String refText) {
        for (String s : refText.split("[\\$\\\n]")) {
            if (!Pattern.matches("^[a-zA-Z]*cycling .*, [a-zA-Z]*cycling.*", s)) {
                continue;
            }
            String newStr = "";
            Pattern p = Pattern.compile(", [a-zA-Z]*cycling");
            Matcher m = p.matcher(s);
            int start = 0;
            while (m.find()) {
                String group = m.group();
                int newStart = m.start();
                newStr += s.substring(start, newStart) + "\n" + group.substring(2, 3).toUpperCase() + group.substring(3);
                start = newStart + group.length();
            }
            newStr += s.substring(start);
            refText = refText.replace(s, newStr);
        }
        return refText;
    }

    @Test
    public void checkSplitCyclingAbilities() {
        // Test the function splitting cycling abilities is correct.

        Assert.assertEquals(
                "Swampcycling {2}\nMountaincycling {2}",
                splitCyclingAbilities("Swampcycling {2}, mountaincycling {2}")
        );
    }

    private String splitManaAbilities(String refText) {
        for (String s : refText.split("[\\$\\\n]")) {
            if (!Pattern.matches("[^\"']*: Add [^\\.]* or.*\\..*", s)) {
                continue;
            }
            // Loyalty Abilities
            if (s.startsWith("0") || s.startsWith("+") || s.startsWith("-")) {
                continue;
            }
            // Leafkin Avenger
            if (s.contains("} for")) {
                continue;
            }

            // Splitting the ability into three segments:
            //
            // {G/W}, {T}: Add {G}{G}, {G}{W}, or {W}{W}. This mana can only be used to cast multicolor spells.
            // ^^^^^^^^^^^^^^^^                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
            //     before      ^^^^^^^^^^^^^^^^^^^^^^^^^                    after
            //                       middle
            int beforeLength = s.indexOf(": Add ");
            String before = s.substring(0, beforeLength + 6);
            int middleIndex = s.indexOf('.', beforeLength);
            String middle = s.substring(beforeLength + 6, middleIndex);
            String after = s.substring(middleIndex);

            //making life easier on the split
            middle = middle
                    .replace(", or ", "|")
                    .replace(" or ", "|")
                    .replace(", ", "|");

            // This now looks like "{G}{G}|{G}{W}|{W}{W}".
            // for each part, make a new line with 'before + part + end'
            String newStr = "";
            for (String part : middle.split("[|]")) {
                newStr += before + part + after + "\n";
            }
            if (!newStr.isEmpty()) {
                newStr = newStr.substring(0, newStr.length() - 1);
            }
            refText = refText.replace(s, newStr);
        }
        return refText;
    }

    @Test
    public void checkSplitManaAbilities() {
        // Test the function splitting mana abilities is correct.

        Assert.assertEquals(
                "{T}: Add {G}.\n{T}: Add {W}.",
                splitManaAbilities("{T}: Add {G} or {W}.")
        );
        Assert.assertEquals(
                "{T}: Add {G}.\n{T}: Add {W}.\n{T}: Add {R}.",
                splitManaAbilities("{T}: Add {G}, {W}, or {R}.")
        );
        Assert.assertEquals(
                "{G/W}, {T}: Add {G}{G}.\n{G/W}, {T}: Add {G}{W}.\n{G/W}, {T}: Add {W}{W}.",
                splitManaAbilities("{G/W}, {T}: Add {G}{G}, {G}{W}, or {W}{W}.")
        );
        Assert.assertEquals(
                "{T}: Add {R}.\n{T}: Add one mana of the chosen color.",
                splitManaAbilities("{T}: Add {R} or one mana of the chosen color.")
        );
        Assert.assertEquals(
                "{T}: Add {B}. Activate only if you control a swamp.\n{T}: Add {U}. Activate only if you control a swamp.",
                splitManaAbilities("{T}: Add {B} or {U}. Activate only if you control a swamp.")
        );


        // Not splitting those:
        Assert.assertEquals(
                "{T}: Each player creates a colorless artifact token named Banana with \"{T}, Sacrifice this artifact: Add {R} or {G}. You gain 2 life.\"",
                splitManaAbilities("{T}: Each player creates a colorless artifact token named Banana with \"{T}, Sacrifice this artifact: Add {R} or {G}. You gain 2 life.\"")
        );
        Assert.assertEquals(
                "+1: Add {R} or {G}. Creature spells you cast this turn can't be countered.",
                splitManaAbilities("+1: Add {R} or {G}. Creature spells you cast this turn can't be countered.")
        );
        Assert.assertEquals(
                "0: Add {R} or {G}. Creature spells you cast this turn can't be countered.",
                splitManaAbilities("0: Add {R} or {G}. Creature spells you cast this turn can't be countered.")
        );
        Assert.assertEquals(
                "-1: Add {R} or {G}. Creature spells you cast this turn can't be countered.",
                splitManaAbilities("-1: Add {R} or {G}. Creature spells you cast this turn can't be countered.")
        );
        Assert.assertEquals(
                "{T}: Add {G} for each creature with power 4 or greater you control.",
                splitManaAbilities("{T}: Add {G} for each creature with power 4 or greater you control.")
        );
    }

    private void checkTypes(Card card, MtgJsonCard ref) {
        if (skipListHaveName(SKIP_LIST_TYPE, card.getExpansionSetCode(), card.getName())) {
            return;
        }

        Collection<String> expected = ref.types;
        List<String> type = new ArrayList<>();
        for (CardType cardType : card.getCardType()) {
            type.add(cardType.toString());
        }
        if (!eqSet(type, expected)) {
            fail(card, "types", type + " != " + expected);
        }
    }

    private void checkPT(Card card, MtgJsonCard ref) {
        if (skipListHaveName(SKIP_LIST_PT, card.getExpansionSetCode(), card.getName())) {
            return;
        }

        // Spacecraft are ignored as they shouldn't have a printed power/toughness but they do in the data
        if (ref.subtypes.contains("Spacecraft")) {
            return;
        }

        if (!eqPT(card.getPower().toString(), ref.power) || !eqPT(card.getToughness().toString(), ref.toughness)) {
            String pt = card.getPower() + "/" + card.getToughness();
            String expected = ref.power + '/' + ref.toughness;
            fail(card, "pt", pt + " != " + expected);
        }
    }

    private boolean eqPT(String found, String expected) {
        if (expected == null) {
            return "0".equals(found);
        } else {
            return found.equals(expected) || expected.contains("*");
        }
    }

    private void checkLoyalty(Card card, MtgJsonCard ref) {
        if (skipListHaveName(SKIP_LIST_LOYALTY, card.getExpansionSetCode(), card.getName())) {
            return;
        }
        if (ref.loyalty == null) {
            if (card.getStartingLoyalty() == -1) {
                return;
            }
        } else if (ref.loyalty.equals("X")) {
            if (card.getStartingLoyalty() == -2) {
                return;
            }
        } else if (ref.loyalty.equals("" + card.getStartingLoyalty())) {
            return;
        }
        fail(card, "loyalty", card.getStartingLoyalty() + " != " + ref.loyalty);
    }

    private void checkDefense(Card card, MtgJsonCard ref) {
        if (skipListHaveName(SKIP_LIST_DEFENSE, card.getExpansionSetCode(), card.getName())) {
            return;
        }
        if (ref.defense == null) {
            if (card.getStartingDefense() == -1) {
                return;
            }
        } else if (ref.defense.equals("X")) {
            if (card.getStartingDefense() == -2) {
                return;
            }
        } else if (ref.defense.equals("" + card.getStartingDefense())) {
            return;
        }
        fail(card, "defense", card.getStartingDefense() + " != " + ref.defense);
    }

    private void checkCost(Card card, MtgJsonCard ref) {
        if (skipListHaveName(SKIP_LIST_COST, card.getExpansionSetCode(), card.getName())) {
            return;
        }

        // TODO: temporary fix - scryfall/mtgjson wrongly add [colors, mana cost] from spell part to main part/card,
        //  example: Ishgard, the Holy See // Faith & Grief
        if (card instanceof CardWithSpellOption && card.isLand()
                || card instanceof SpellOptionCard && ((SpellOptionCard) card).getParentCard().isLand()) {
            return;
        }

        String expected = ref.manaCost;
        String cost = String.join("", card.getManaCostSymbols());
        if (cost.isEmpty()) {
            cost = null;
        }
        if (cost != null) {
            cost = cost.replaceAll("P\\}", "P}");
        }
        if (!Objects.equals(cost, expected)) {
            fail(card, "cost", cost + " != " + expected);
        }
    }

    private boolean isBasicLandName(String name) {

        String checkName = name;
        if (name.startsWith("Snow-Covered ")) {
            // snow lands is basic lands too
            checkName = name.replace("Snow-Covered ", "");
        }

        return checkName.equals("Island")
                || checkName.equals("Forest")
                || checkName.equals("Swamp")
                || checkName.equals("Plains")
                || checkName.equals("Mountain");
    }

    private boolean isNonSnowBasicLandName(String name) {
        return name.equals("Island")
                || name.equals("Forest")
                || name.equals("Swamp")
                || name.equals("Plains")
                || name.equals("Mountain");
    }

    private void checkRarityAndBasicLands(Card card, MtgJsonCard ref) {
        if (skipListHaveName(SKIP_LIST_RARITY, card.getExpansionSetCode(), card.getName())) {
            return;
        }

        // basic lands must have Rarity.LAND and SuperType.BASIC
        // other cards can't have that stats
        String name = card.getName();
        if (isBasicLandName(name)) {
            // lands
            if (card.getRarity() != Rarity.LAND) {
                fail(card, "rarity", "basic land must be Rarity.LAND");
            }

            if (!card.isBasic()) {
                fail(card, "supertype", "basic land must be SuperType.BASIC");
            }
        } else if (name.equals("Wastes") || name.equals("Snow-Covered Wastes")) {
            // Wastes are SuperType.BASIC but not necessarily Rarity.LAND
            if (!card.isBasic()) {
                fail(card, "supertype", "Wastes must be SuperType.BASIC");
            }
        } else {
            // non lands
            if (card.getRarity() == Rarity.LAND) {
                fail(card, "rarity", "only basic land can be Rarity.LAND");
            } else if (!card.getRarity().equals(ref.getRarity())) {
                fail(card, "rarity", "mismatched. MtgJson has " + ref.getRarity() + " while set file has " + card.getRarity());
            }

            if (card.isBasic()) {
                fail(card, "supertype", "only basic land can be SuperType.BASIC");
            }
        }
    }

    @Test
    public void test_checkCardRatingConsistency() {
        // all cards with same name must have same rating (see RateCard.rateCard)
        // cards rating must be consistency (same) for card sorting
        List<Card> cardsList = new ArrayList<>(CardScanner.getAllCards());
        Map<String, Integer> cardRates = new HashMap<>();
        for (Card card : cardsList) {
            int curRate = RateCard.rateCard(card, Collections.emptyList(), false);
            int prevRate = cardRates.getOrDefault(card.getName(), 0);
            if (prevRate == 0) {
                cardRates.putIfAbsent(card.getName(), curRate);
            } else {
                if (curRate != prevRate) {
                    Assert.fail("Card with same name have different ratings: " + card.getName());
                }
            }
        }
    }

    @Test
    public void test_checkCardConstructors() {
        // create all cards, can catch additional verify and runtime checks from abilities and effects
        // example: wrong code usage errors
        //
        // warning, look at stack trace logs, not card names -- some error code can be hidden in static methods and can be called from un-related cards
        // use test_showCardInfo for detailed errors
        Collection<String> errorsList = new ArrayList<>();
        Collection<ExpansionSet> sets = Sets.getInstance().values();
        for (ExpansionSet set : sets) {
            for (ExpansionSet.SetCardInfo setInfo : set.getSetCardInfo()) {
                try {
                    Card card = CardImpl.createCard(setInfo.getCardClass(), new CardSetInfo(setInfo.getName(), set.getCode(),
                            setInfo.getCardNumber(), setInfo.getRarity(), setInfo.getGraphicInfo()));
                    if (card == null) {
                        errorsList.add("Error: can't create card - " + setInfo.getCardClass() + " - see logs for errors");
                        continue;
                    }
                    if (!card.getExpansionSetCode().equals(set.getCode())) {
                        errorsList.add("Error: card constructor have custom expansionSetCode, must be removed " + setInfo.getCardClass());
                    }
                } catch (Throwable e) {
                    // CardImpl.createCard don't throw exceptions (only error logs), so that logs are useless here
                    errorsList.add("Error: can't create card - " + setInfo.getCardClass() + " - see logs for errors");
                }
            }
        }

        if (!errorsList.isEmpty()) {
            printMessages(errorsList);
            Assert.fail("Found " + errorsList.size() + " broken cards, look at logs above for more details");
        }
    }

    @Test
    public void test_checkCardsInCubes() throws Exception {
        Reflections reflections = new Reflections("mage.tournament.cubes.");
        Set<Class<? extends DraftCube>> cubesList = reflections.getSubTypesOf(DraftCube.class);
        Assert.assertFalse("Can't find any cubes", cubesList.isEmpty());

        CardScanner.scan();
        Collection<String> errorsList = new ArrayList<>();
        for (Class<? extends DraftCube> cubeClass : cubesList) {
            // need drafts with fixed cards list (constructor with zero params)
            if (Arrays.stream(cubeClass.getConstructors()).noneMatch(c -> c.getParameterCount() == 0)) {
                continue;
            }

            // cube from deck must use real deck to check complete
            DraftCube cube;
            if (cubeClass.isAssignableFrom(CubeFromDeck.class)) {
                DeckCardLists deckCardLists = new DeckCardLists();
                deckCardLists.setCards(Arrays.asList(
                        new DeckCardInfo("Adanto Vanguard", "1", "XLN"),
                        new DeckCardInfo("Boneyard Parley", "94", "XLN"),
                        new DeckCardInfo("Forest", "276", "XLN")
                ));
                Deck deck = Deck.load(deckCardLists, true);
                Constructor<?> con = cubeClass.getConstructor(Deck.class);
                cube = (DraftCube) con.newInstance(deck);
                Assert.assertFalse(deckCardLists.getCards().isEmpty());
                Assert.assertEquals("deck must be loaded to cube", cube.getCubeCards().size(), deckCardLists.getCards().size());
                Assert.assertTrue("cube's name must contains cards count", cube.getName().contains(deckCardLists.getCards().size() + " cards"));
            } else {
                cube = (DraftCube) createNewObject(cubeClass);
            }
            if (cube.getCubeCards().isEmpty()) {
                errorsList.add("Error: broken cube, empty cards list: " + cube.getClass().getCanonicalName());
            }

            for (DraftCube.CardIdentity cardId : cube.getCubeCards()) {
                // same find code as original cube
                CardInfo cardInfo;
                if (!cardId.getExtension().isEmpty()) {
                    cardInfo = CardRepository.instance.findCardWithPreferredSetAndNumber(cardId.getName(), cardId.getExtension(), null);
                } else {
                    cardInfo = CardRepository.instance.findPreferredCoreExpansionCard(cardId.getName());
                }
                if (cardInfo == null) {
                    errorsList.add("Error: broken cube, can't find card: " + cube.getClass().getCanonicalName() + " - " + cardId.getName());
                }
            }
        }

        if (!errorsList.isEmpty()) {
            printMessages(errorsList);
            Assert.fail("Found " + errorsList.size() + " errors in the cubes, look at logs above for more details");
        }
    }

    @Test
    public void test_checkUnicodeCardNamesForImport() {
        // deck import can catch real card names with non-ascii symbols like Arwen Undómiel, so it must be able to process it

        // check unicode card
        MtgJsonCard card = MtgJsonService.cardFromSet("LTR", "Arwen Undomiel", "194");
        Assert.assertNotNull("test card must exists", card);
        Assert.assertTrue(card.isUseUnicodeName());
        Assert.assertEquals("Arwen Undomiel", card.getNameAsASCII());
        Assert.assertEquals("Arwen Undómiel", card.getNameAsUnicode());
        Assert.assertEquals("Arwen Undomiel", card.getNameAsFull());

        // mtga format can contain /// in the names, so check it too
        // see https://github.com/magefree/mage/pull/9855
        Assert.assertEquals("Dusk // Dawn", CardNameUtil.normalizeCardName("Dusk /// Dawn"));

        // check all converters
        Collection<String> errorsList = new ArrayList<>();
        MtgJsonService.sets().values().forEach(jsonSet -> {
            jsonSet.cards.forEach(jsonCard -> {
                if (jsonCard.isUseUnicodeName()) {
                    String inName = jsonCard.getNameAsUnicode();
                    String outName = CardNameUtil.normalizeCardName(inName);
                    String needOutName = jsonCard.getNameAsFace();
                    if (!outName.equals(needOutName)) {
                        // how-to fix: add new unicode symbol in CardNameUtil.normalizeCardName
                        errorsList.add(String.format("error, found unsupported unicode symbol in %s - %s", inName, jsonSet.code));
                    }
                }
            });
        });
        printMessages(errorsList);
        if (errorsList.size() > 0) {
            Assert.fail(String.format("Card name converters contains unsupported unicode symbols in %d cards, see logs above", errorsList.size()));
        }
    }

    /**
     * Not really a test. Used to make the changelog diff list
     * for sets that are heavily worked on.
     */
    @Ignore
    @Test
    public void list_ChangelogHelper() {

        String setCode = "LCC";
        int maxCards = 100; // don't want to look above that card number, as those are alternate prints.
        boolean doExclude = false; // use the excluded array or not.

        // Excluded in that list, either already listed in a previous changelog, or exceptions.
        Set<Integer> excluded = new HashSet<>(Arrays.asList(
                8, 9, 49, 71, 76, 79, 80, 89, 90, 92, 96, 97
        ));

        for (int i = 17; i <= 68; ++i) {
            excluded.add(i); // alternates version of the new cards.
        }

        /*
        String setCode = "LCI";
        int maxCards = 285; // don't want to look above that card number, as those are alternate prints.
        boolean doExclude = false; // use the excluded array or not.

        // Excluded in that list, either already listed in a previous changelog, or exceptions.
        Set<Integer> excluded = new HashSet<>(Arrays.asList(
                1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 40, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 127, 128, 129, 130, 131, 132, 133, 134, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, 275, 276, 277, 278, 279, 280, 281, 282, 283, 284
        ));
        */

        Set<Integer> listChangelog = new HashSet<>();
        List<ExpansionSet.SetCardInfo> setInfo = Sets.getInstance().get(setCode).getSetCardInfo();
        for (ExpansionSet.SetCardInfo sci : setInfo) {
            int cn = sci.getCardNumberAsInt();
            if (cn > maxCards) {
                continue;
            }
            if (doExclude && excluded.contains(cn)) {
                continue;
            }
            listChangelog.add(cn);
        }

        List<Integer> sorted = listChangelog.stream().sorted().collect(Collectors.toList());

        // to manual update the excluded array
        System.out.println(sorted.stream().map(cn -> cn + "").collect(Collectors.joining(", ")));
        // Scryfall list of all the new cards for that set
        System.out.println(
                "https://scryfall.com/search?q=s%3A" + setCode + "+-is%3Areprint+%28"
                        + sorted.stream().map(cn -> "cn%3A" + cn).collect(Collectors.joining("+or+"))
                        + "%29&order=set&as=grid&unique=cards"
        );
    }

    /**
     * Helper test to download infinite combos data and prepare it to use in Commander Brackets score system
     * <p>
     * How-to use: run it before each main release and upload updated files to github
     */
    @Ignore
    @Test
    public void downloadAndPrepareCommanderBracketsData() {
        // download data
        // load data by pages, max limit = 100, no needs to setup it, ~2000 combos or 20 pages
        String nextUrl = "https://backend.commanderspellbook.com/variants?format=json&group_by_combo=true&ordering=created&q=cards%3D2+result%3Ainfinite";
        SpellBookCardsPage page;
        int pageNumber = 0;
        List<String> allCombos = new ArrayList<>();
        while (nextUrl != null && !nextUrl.isEmpty()) {
            pageNumber++;
            System.out.println("downloading page " + pageNumber);
            String res = XmageURLConnection.downloadText(nextUrl);
            page = new Gson().fromJson(res, SpellBookCardsPage.class);
            if (page == null || page.results == null) {
                System.out.println("ERROR, unknown data format: " + res.substring(0, 10) + "...");
                return;
            }
            page.results.forEach(combo -> {
                if (combo.uses.isEmpty()) {
                    System.out.println("wrong combo uses: " + combo.uses);
                    return;
                }
                // Stella Lee, Wild Card - can generate infinite combo by itself, so allow 1 card
                String card1 = combo.uses.get(0).card.name;
                String card2 = combo.uses.size() == 1 ? card1 : combo.uses.get(1).card.name;
                if (card1 != null && card2 != null) {
                    allCombos.add(String.format("%s@%s", card1, card2));
                }
            });

            nextUrl = page.next;
        }

        // save results (run from Mage.Verify)
        File destFile = new TFile("..\\Mage\\src\\main\\resources\\brackets\\infinite-combos.txt");
        if (!destFile.exists()) {
            System.out.println("Can't find dest file " + destFile);
            return;
        }

        List<String> infiniteCombosRes;
        try {
            infiniteCombosRes = Files.readAllLines(destFile.toPath(), StandardCharsets.UTF_8);
        } catch (IOException e) {
            System.out.println("Can't read file " + destFile + " " + e);
            return;
        }

        // replace all cards data, but keep comments
        infiniteCombosRes.removeIf(s -> !s.startsWith("#")
                || s.startsWith("# Source")
                || s.startsWith("# Updated")
                || s.startsWith("# Found")
        );
        infiniteCombosRes.add(String.format("# Source: %s", "https://commanderspellbook.com"));
        infiniteCombosRes.add(String.format("# Updated: %s", LocalDate.now().format(DateTimeFormatter.ISO_DATE)));
        infiniteCombosRes.add(String.format("# Found: %d", allCombos.size()));
        infiniteCombosRes.addAll(allCombos); // do not sort, all new combos will be added to the end due spell book default order

        try {
            Files.write(destFile.toPath(), infiniteCombosRes, StandardCharsets.UTF_8);
        } catch (IOException e) {
            System.out.println("Can't write file " + destFile + " " + e);
            return;
        }

        System.out.println(String.format("ALL DONE, found and write %d combos", allCombos.size()));
    }
}