settings.ts

import { Algorithm } from "src/algorithms/base/isrs-algorithm";
import { DataStoreName } from "src/data-stores/base/data-store";
import { t } from "src/lang/helpers";
import { pathMatchesPattern } from "src/utils/fs";

export interface SRSettings {
    // flashcards
    flashcardTags: string[];
    flashcardTagsToIgnore: string[];
    convertFoldersToDecks: boolean;
    burySiblingCards: boolean;
    randomizeCardOrder: boolean | undefined;
    flashcardCardOrder: string;
    flashcardDeckOrder: string;
    convertClozePatternsToInputs: boolean;
    convertHighlightsToClozes: boolean;
    convertBoldTextToClozes: boolean;
    convertCurlyBracketsToClozes: boolean;
    clozePatterns: string[];
    singleLineCardSeparator: string;
    singleLineReversedCardSeparator: string;
    multilineCardSeparator: string;
    multilineReversedCardSeparator: string;
    multilineCardEndMarker: string;
    editLaterTag: string;

    // notes
    enableNoteReviewPaneOnStartup: boolean;
    tagsToReview: string[];
    noteTagsToIgnore: string[];
    noteFoldersToIgnore: string[];
    openRandomNote: boolean;
    autoNextNote: boolean;
    disableFileMenuReviewOptions: boolean | undefined;
    showFileMenuReviewOptions: boolean;
    deleteTagsOnSchedulingDataDeletion: boolean;
    maxNDaysNotesReviewQueue: number;

    // UI preferences
    showRibbonIcon: boolean;
    showStatusBar: boolean;
    showCardStatusBarItem: boolean;
    showNoteStatusBarItem: boolean;
    showUpdateAvailableStatusBarItem: boolean;
    initiallyExpandAllSubdecksInTree: boolean;
    showContextInCards: boolean;
    showIntervalInReviewButtons: boolean;
    flashcardHeightPercentage: number;
    flashcardWidthPercentage: number;
    flashcardHeightPercentageMobile: number;
    flashcardWidthPercentageMobile: number;
    flashcardAgainText: string;
    flashcardEasyText: string;
    flashcardGoodText: string;
    flashcardHardText: string;
    reviewButtonDelay: number;
    openViewInNewTabMobile: boolean;
    showDeleteButtonInCardView: boolean;
    showDeleteButtonInFileMenu: boolean;
    openViewInNewTab: boolean;
    useCustomHotkeys: boolean;

    // algorithm
    algorithm: string;
    baseEase: number;
    lapsesIntervalChange: number;
    easyBonus: number;
    loadBalance: boolean;
    maximumInterval: number;
    maxLinkFactor: number;
    fsrsDesiredRetention: number;
    startOfDay: string;

    // storage
    dataStore: string;
    cardCommentOnSameLine: boolean;

    // logging
    showSchedulingDebugMessages: boolean;
    showParserDebugMessages: boolean;

    preferredDateFormatForNoteReviewQueue: string;
}

export const DEFAULT_SETTINGS: SRSettings = {
    // flashcards
    flashcardTags: ["#flashcards"],
    flashcardTagsToIgnore: [],
    convertFoldersToDecks: false,
    burySiblingCards: false,
    flashcardCardOrder: "DueFirstRandom",
    flashcardDeckOrder: "PrevDeckComplete_Sequential",
    convertClozePatternsToInputs: false,
    convertHighlightsToClozes: true,
    convertBoldTextToClozes: false,
    convertCurlyBracketsToClozes: false,
    clozePatterns: ["==[123;;]answer[;;hint]=="],
    singleLineCardSeparator: "::",
    singleLineReversedCardSeparator: ":::",
    multilineCardSeparator: "?",
    multilineReversedCardSeparator: "??",
    multilineCardEndMarker: "",
    editLaterTag: "#edit-later",
    randomizeCardOrder: undefined,

    // notes
    enableNoteReviewPaneOnStartup: true,
    tagsToReview: ["#review"],
    noteTagsToIgnore: [],
    noteFoldersToIgnore: ["**/*.excalidraw.md"],
    openRandomNote: false,
    autoNextNote: false,
    disableFileMenuReviewOptions: undefined,
    showFileMenuReviewOptions: true,
    deleteTagsOnSchedulingDataDeletion: false,
    maxNDaysNotesReviewQueue: 365,

    // UI settings
    showRibbonIcon: true,
    showStatusBar: true,
    showCardStatusBarItem: true,
    showNoteStatusBarItem: true,
    showUpdateAvailableStatusBarItem: true,
    initiallyExpandAllSubdecksInTree: true,
    showContextInCards: true,
    showIntervalInReviewButtons: true,
    flashcardHeightPercentage: 60,
    flashcardWidthPercentage: 60,
    flashcardHeightPercentageMobile: 100,
    flashcardWidthPercentageMobile: 100,
    flashcardAgainText: t("AGAIN"),
    flashcardEasyText: t("EASY"),
    flashcardGoodText: t("GOOD"),
    flashcardHardText: t("HARD"),
    reviewButtonDelay: 0,
    showDeleteButtonInCardView: false,
    showDeleteButtonInFileMenu: false,
    openViewInNewTab: false,
    openViewInNewTabMobile: false,
    useCustomHotkeys: false,

    // algorithm
    algorithm: Algorithm.SM_2_OSR,
    baseEase: 250,
    lapsesIntervalChange: 0.5,
    easyBonus: 1.3,
    loadBalance: true,
    maximumInterval: 36525,
    maxLinkFactor: 1.0,
    fsrsDesiredRetention: 0.9,
    startOfDay: "00:00:00",

    // storage
    dataStore: DataStoreName.NOTES,
    cardCommentOnSameLine: false,

    // logging
    showSchedulingDebugMessages: false,
    showParserDebugMessages: false,
    preferredDateFormatForNoteReviewQueue: "MMM DD YYYY",
};

export function upgradeSettings(settings: SRSettings) {
    if (
        settings.randomizeCardOrder !== null &&
        settings.randomizeCardOrder !== undefined &&
        (settings.flashcardCardOrder === null || settings.flashcardCardOrder === undefined) &&
        (settings.flashcardDeckOrder === null || settings.flashcardDeckOrder === undefined)
    ) {
        settings.flashcardCardOrder = settings.randomizeCardOrder
            ? "DueFirstRandom"
            : "DueFirstSequential";
        settings.flashcardDeckOrder = "PrevDeckComplete_Sequential";

        // After the upgrade, we don't need the old attribute any more
        settings.randomizeCardOrder = undefined;
    }

    if (settings.clozePatterns === null || settings.clozePatterns === undefined) {
        settings.clozePatterns = [];

        if (settings.convertHighlightsToClozes)
            settings.clozePatterns.push("==[123;;]answer[;;hint]==");

        if (settings.convertBoldTextToClozes)
            settings.clozePatterns.push("**[123;;]answer[;;hint]**");

        if (settings.convertCurlyBracketsToClozes)
            settings.clozePatterns.push("{{[123;;]answer[;;hint]}}");
    }

    if (settings.disableFileMenuReviewOptions !== undefined) {
        settings.disableFileMenuReviewOptions = undefined;
    }

    if (settings.fsrsDesiredRetention === null || settings.fsrsDesiredRetention === undefined) {
        settings.fsrsDesiredRetention = DEFAULT_SETTINGS.fsrsDesiredRetention;
    }
}

export class SettingsUtil {
    static isFlashcardTag(settings: SRSettings, tag: string): boolean {
        return SettingsUtil.isTagInList(settings.flashcardTags, tag);
    }

    static isPathInNoteIgnoreFolder(settings: SRSettings, path: string): boolean {
        return settings.noteFoldersToIgnore.some((folder) => pathMatchesPattern(path, folder));
    }

    static isAnyTagANoteReviewTag(settings: SRSettings, tags: string[]): boolean {
        for (const tag of tags) {
            if (
                settings.tagsToReview.some((tagToReview) =>
                    this.isSubTagContainedInTag(tagToReview, tag),
                )
            ) {
                return true;
            }
        }
        return false;
    }

    static isAnyTagIgnoredForFlashcards(settings: SRSettings, tags: string[]): boolean {
        return tags.some((tag) => SettingsUtil.isTagInList(settings.flashcardTagsToIgnore, tag));
    }

    static isAnyTagIgnoredForNotes(settings: SRSettings, tags: string[]): boolean {
        return tags.some((tag) => SettingsUtil.isTagInList(settings.noteTagsToIgnore, tag));
    }

    // Given a list of tags, return the subset that is in settings.tagsToReview
    static filterForNoteReviewTag(settings: SRSettings, tags: string[]): string[] {
        const result: string[] = [];
        for (const tagToReview of settings.tagsToReview) {
            if (tags.some((tag) => this.isSubTagContainedInTag(tagToReview, tag))) {
                result.push(tagToReview);
            }
        }
        return result;
    }

    /**
     * Checks if the tag is in the tagList.
     *
     * @param tagList - The list of tags to check.
     * @param tag - The tag to check.
     * @param exactMatch - Whether to match the tag exactly or if it should be a sub tag.
     * @returns true if the tag is in the tagList, false otherwise.
     */
    public static isTagInList(
        tagList: string[],
        tag: string,
        exactMatch: boolean = false,
    ): boolean {
        // This should be true, if the tag is fully contained in a tag from the list
        for (const tagFromList of tagList) {
            if (exactMatch) {
                if (tagFromList === tag) {
                    // The tag from the list is the same as the current tag, so it is contained in it
                    return true;
                }
            } else {
                // In this case we need to look more in detail to see if the tag is fully contained in the tag from the list
                if (this.isSubTagContainedInTag(tagFromList, tag)) {
                    // The tag from the list is contained in the current tag, so it is contained in it
                    return true;
                }
            }
        }
        return false;
    }

    /**
     * Checks if the subTag is contained in the tag.
     *
     * @param tag - The tag to check.
     * @param subTag - The subTag to check.
     * @returns true if the subTag is contained in the tag, false otherwise.
     */
    public static isSubTagContainedInTag(tag: string, subTag: string): boolean {
        if (tag === subTag || subTag.startsWith(tag + "/")) {
            // The tag is the same as the sub tag, or the sub tag is contained in the tag
            return true;
        }
        return false;
    }
}