/*
This file is part of the Notesnook project (https://notesnook.com/)

Copyright (C) 2023 Streetwriters (Private) Limited

This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/
import { mergeAttributes, Node } from "@tiptap/core";
// export const inputRegex = /^\s*(\[([( |x])?\])\s$/;
export const CheckListItem = Node.create({
    name: "checkListItem",
    addOptions() {
        return {
            nested: false,
            HTMLAttributes: {}
        };
    },
    content() {
        return this.options.nested ? "paragraph block*" : "paragraph+";
    },
    defining: true,
    addAttributes() {
        return {
            checked: {
                default: false,
                keepOnSplit: false,
                parseHTML: (element) => element.classList.contains("checked"),
                renderHTML: (attributes) => ({
                    class: attributes.checked ? "checked" : ""
                })
            }
        };
    },
    parseHTML() {
        return [
            {
                tag: `li.simple-checklist--item`,
                priority: 51
            }
        ];
    },
    renderHTML({ HTMLAttributes }) {
        return [
            "li",
            mergeAttributes(this.options.HTMLAttributes, HTMLAttributes, {
                class: "simple-checklist--item"
            }),
            0
        ];
    },
    addKeyboardShortcuts() {
        const shortcuts = {
            Enter: () => this.editor.commands.splitListItem(this.name),
            "Shift-Tab": () => this.editor.commands.liftListItem(this.name)
        };
        if (!this.options.nested) {
            return shortcuts;
        }
        return Object.assign(Object.assign({}, shortcuts), { Tab: () => this.editor.commands.sinkListItem(this.name) });
    },
    addNodeView() {
        return ({ node, getPos, editor }) => {
            const listItem = document.createElement("li");
            const checkboxWrapper = document.createElement("label");
            const checkboxStyler = document.createElement("span");
            const checkbox = document.createElement("input");
            const content = document.createElement("div");
            checkboxWrapper.contentEditable = "false";
            checkbox.type = "checkbox";
            checkbox.addEventListener("mousedown", (event) => {
                if (globalThis.keyboardShown) {
                    event.preventDefault();
                }
            });
            checkbox.addEventListener("change", (event) => {
                event.preventDefault();
                // if the editor isn’t editable and we don't have a handler for
                // readonly checks we have to undo the latest change
                if (!editor.isEditable && !this.options.onReadOnlyChecked) {
                    checkbox.checked = !checkbox.checked;
                    return;
                }
                const { checked } = event.target;
                if (editor.isEditable && typeof getPos === "function") {
                    editor
                        .chain()
                        .command(({ tr }) => {
                        const position = getPos();
                        const currentNode = tr.doc.nodeAt(position);
                        tr.setNodeMarkup(position, undefined, Object.assign(Object.assign({}, currentNode === null || currentNode === void 0 ? void 0 : currentNode.attrs), { checked }));
                        return true;
                    })
                        .run();
                }
                if (!editor.isEditable && this.options.onReadOnlyChecked) {
                    // Reset state if onReadOnlyChecked returns false
                    if (!this.options.onReadOnlyChecked(node, checked)) {
                        checkbox.checked = !checkbox.checked;
                    }
                }
            });
            if (node.attrs.checked) {
                checkbox.setAttribute("checked", "checked");
            }
            checkboxWrapper.append(checkbox, checkboxStyler);
            listItem.append(checkboxWrapper, content);
            return {
                dom: listItem,
                contentDOM: content,
                update: (updatedNode) => {
                    if (updatedNode.type !== this.type) {
                        return false;
                    }
                    listItem.dataset.checked = updatedNode.attrs.checked;
                    if (updatedNode.attrs.checked) {
                        checkbox.setAttribute("checked", "checked");
                    }
                    else {
                        checkbox.removeAttribute("checked");
                    }
                    return true;
                }
            };
        };
    }
    // addInputRules() {
    //   return [
    //     wrappingInputRule({
    //       find: inputRegex,
    //       type: this.type,
    //       getAttributes: (match) => ({
    //         checked: match[match.length - 1] === "x"
    //       })
    //     })
    //   ];
    // }
});
